tina4-nodejs 3.13.69 → 3.13.70

package/CLAUDE.md

@@ -1,10 +1,10 @@
-# CLAUDE.md - AI Developer Guide for tina4-nodejs (v3.13.69)
+# CLAUDE.md - AI Developer Guide for tina4-nodejs (v3.13.70)
 
 > 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.69 - 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.70 - 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.
 
@@ -1238,7 +1238,7 @@ When adding new features, add a corresponding `test/<feature>.test.ts` file.
 ## v3 Features Summary
 
 - **45 built-in features**, zero third-party dependencies
-- **5,332 tests** passing across all modules
+- **5,379 tests** passing across 154 files (build + typecheck green; 9 PostgreSQL/Valkey service-gated failures)
 - **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

@@ -1,6 +1,6 @@
 {
   "name": "tina4-nodejs",
-  "version": "3.13.69",
+  "version": "3.13.70",
   "type": "module",
   "description": "Tina4 for Node.js/TypeScript - 54 built-in features, zero dependencies",
   "keywords": [
@@ -60,6 +60,13 @@
   "engines": {
     "node": ">=22.0.0"
   },
+  "optionalDependencies": {
+    "@aws-sdk/client-s3": "^3.600.0",
+    "@aws-sdk/s3-request-presigner": "^3.600.0",
+    "mongodb": "^6.0.0",
+    "pg": "^8.20.0",
+    "redis": "^4.7.0"
+  },
   "devDependencies": {
     "@types/node": "^22.10.0",
     "esbuild": "^0.24.0",

package/packages/core/src/ai.ts

@@ -4,7 +4,7 @@
  * Simple menu-driven installer for AI tool context files.
  * The user picks which tools they use, we install the appropriate files.
  *
- *   import { showMenu, installSelected } from "@tina4/core";
+ *   import { showMenu, installSelected } from "tina4-nodejs";
  */
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -693,7 +693,7 @@ Set \`TINA4_DATABASE_URL\` in \`.env\` (e.g. \`postgres://localhost:5432/mydb\`)
 
 ## Auth
 
-JWT auth built in. \`import { createToken, validateToken, hashPassword, checkPassword } from "@tina4/core"\`.
+JWT auth built in. \`import { createToken, validateToken, hashPassword, checkPassword } from "tina4-nodejs"\`.
 GET routes are public. POST/PUT/PATCH/DELETE require auth by default.
 `;
 }
@@ -862,7 +862,7 @@ Set \`TINA4_DATABASE_URL\` in \`.env\` (e.g. \`sqlite:///path/to/db.sqlite\`, \`
 
 ## Auth
 
-JWT auth built in. \`import { createToken, validateToken, hashPassword, checkPassword } from "@tina4/core"\`.
+JWT auth built in. \`import { createToken, validateToken, hashPassword, checkPassword } from "tina4-nodejs"\`.
 GET routes are public. POST/PUT/PATCH/DELETE require auth by default.
 
 ## Testing
@@ -873,7 +873,7 @@ npx tina4nodejs test      # Run all tests
 
 Add test files in \`test/\` directory. Use built-in inline testing:
 \`\`\`typescript
-import { tests, assertEqual, runAll } from "@tina4/core";
+import { tests, assertEqual, runAll } from "tina4-nodejs";
 \`\`\`
 
 ## Important

package/packages/core/src/cache.ts

@@ -1017,7 +1017,7 @@ class DatabaseBackend implements CacheBackend {
     process.env.TINA4_AUTO_CACHING = "false";
     process.env.TINA4_DB_CACHE = "false";
     try {
-      const mod: any = await import("@tina4/orm").catch(() => null);
+      const mod: any = await import("../../orm/src/index.js").catch(() => null);
       if (!mod || !mod.initDatabase) { this.available = false; return; }
       const db = await mod.initDatabase({ url: this.url });
       await db.execute(

package/packages/core/src/devAdmin.ts

@@ -518,7 +518,7 @@ export class DevAdmin {
 
           // Auto-discover ORM models from BaseModel registry
           try {
-            const orm = await import("@tina4/orm");
+            const orm = await import("../../orm/src/index.js");
             const registry = (orm as any).BaseModel?._modelRegistry as Record<string, any> | undefined;
             if (registry) {
               for (const modelClass of Object.values(registry)) {
@@ -746,7 +746,7 @@ function handleStatus(router: Router): RouteHandler {
     const mailboxCounts = DevMailboxStore.count();
     let dbTableCount = 0;
     try {
-      const { getAdapter } = await import("@tina4/orm");
+      const { getAdapter } = await import("../../orm/src/index.js");
       const db = getAdapter();
       dbTableCount = db.tables().length;
     } catch { /* no database connected */ }
@@ -852,7 +852,7 @@ const handleSystem: RouteHandler = async (_req, res) => {
   let dbTableCount: number | undefined;
   let dbConnected = false;
   try {
-    const { getAdapter } = await import("@tina4/orm");
+    const { getAdapter } = await import("../../orm/src/index.js");
     const db = getAdapter();
     dbTableCount = db.tables().length;
     dbConnected = true;
@@ -1067,7 +1067,7 @@ const handleTable: RouteHandler = (req, res) => {
 
 const handleTables: RouteHandler = async (_req, res) => {
   try {
-    const { getAdapter } = await import("@tina4/orm");
+    const { getAdapter } = await import("../../orm/src/index.js");
     const db = getAdapter();
     const tables = db.tables();
     res.json({ tables });
@@ -1093,7 +1093,7 @@ const handleSeed: RouteHandler = async (req, res) => {
     return;
   }
   try {
-    const orm = await import("@tina4/orm");
+    const orm = await import("../../orm/src/index.js");
     const db = orm.getAdapter();
     const { seedTable } = orm;
     // A shared FakeData seeds the RNG so a `seed` makes the run reproducible.
@@ -1144,7 +1144,7 @@ const handleQuery: RouteHandler = async (req, res) => {
   }
 
   try {
-    const { getAdapter } = await import("@tina4/orm");
+    const { getAdapter } = await import("../../orm/src/index.js");
     const db = getAdapter();
 
     // Split multiple statements on semicolons
@@ -1519,7 +1519,7 @@ const handleConnectionsTest: RouteHandler = async (req, res) => {
   }
   try {
     // Try to use the ORM's initDatabase if available
-    const { initDatabase } = await import("@tina4/orm").catch(() => ({ initDatabase: null }));
+    const { initDatabase } = await import("../../orm/src/index.js").catch(() => ({ initDatabase: null }));
     if (!initDatabase) {
       res.json({ success: false, error: "Database module (@tina4/orm) not available" });
       return;

package/packages/core/src/mcp.ts

@@ -39,11 +39,13 @@ const req = createRequire(import.meta.url);
  * MCP client hits /__dev/mcp from a from-source dev server.
  */
 function reqSibling(pkg: "orm" | "swagger" | "frond"): Record<string, unknown> {
-  try {
-    return req(`@tina4/${pkg}`) as Record<string, unknown>;
-  } catch {
-    return req(`../../${pkg}/src/index.ts`) as Record<string, unknown>;
-  }
+  // Resolve the sibling package from its in-repo/installed SOURCE path. A bare
+  // `@tina4/${pkg}` specifier does NOT resolve in a consumer install — the root
+  // `tina4-nodejs` package is the only thing on disk, there is no `@tina4/*` in
+  // node_modules (that was the #32 break) — so go straight to the relative src.
+  // createRequire + tsx resolves the .ts here (synchronous dev-tool path); each
+  // caller already wraps this in try/catch and degrades gracefully on failure.
+  return req(`../../${pkg}/src/index.ts`) as Record<string, unknown>;
 }
 
 // ── Types ─────────────────────────────────────────────────────
@@ -1187,13 +1189,43 @@ export function registerDevTools(server: McpServer): void {
 
   server.registerTool(
     "route_test",
-    (args) => {
-      // Simplified: return info about what would be tested
-      return {
-        info: "Route testing requires the test client",
-        method: args.method,
-        path: args.path,
-      };
+    async (args) => {
+      // Dispatch the route through the REAL in-process TestClient (parity with
+      // the Python master's route_test, which drives its TestClient). Previously
+      // an echo stub that returned {info,method,path} and never dispatched.
+      // The TestClient builds a mock request, matches the route on the active
+      // router, runs it through the real auth gate, and executes the handler —
+      // exactly like a live request, no socket. Returns {status, body, contentType}.
+      try {
+        const { TestClient } = req("./testClient.js") as typeof import("./testClient.js");
+        const { defaultRouter } = req("./router.js") as typeof import("./router.js");
+        // Same router accessor route_list uses: prefer the running server's
+        // router, fall back to the default global router.
+        const router = (globalThis as any).__tina4_router ?? defaultRouter;
+        const client = new TestClient(router);
+        const method = String(args.method ?? "GET").toUpperCase();
+        const routePath = String(args.path ?? "");
+        const bodyStr = args.body ? String(args.body) : undefined;
+        let headers: Record<string, string> = {};
+        try {
+          headers = args.headers ? JSON.parse(String(args.headers)) : {};
+        } catch {
+          headers = {};
+        }
+        const options = { body: bodyStr, headers };
+        let resp;
+        switch (method) {
+          case "GET": resp = await client.get(routePath, options); break;
+          case "POST": resp = await client.post(routePath, options); break;
+          case "PUT": resp = await client.put(routePath, options); break;
+          case "PATCH": resp = await client.patch(routePath, options); break;
+          case "DELETE": resp = await client.delete(routePath, options); break;
+          default: return { error: `Unsupported method: ${method}` };
+        }
+        return { status: resp.status, body: resp.text(), contentType: resp.contentType };
+      } catch (e) {
+        return { error: (e as Error).message };
+      }
     },
     "Call a route and return the response",
     schemaFromParams([
@@ -1379,18 +1411,28 @@ export function registerDevTools(server: McpServer): void {
     "migration_status",
     async (_args) => {
       try {
-        const db = (globalThis as any).__tina4_db;
-        if (!db) return { error: "No database connection" };
         // Use the real migration API (parity with the Python master, whose MCP
-        // migration_status calls MigrationRunner(db).status()). Previously a stub.
-        // Load orm via dynamic ESM import (the same mechanism server.ts uses for
-        // autoMigrateOnStartup) — reqSibling()'s createRequire fails here because
-        // @tina4/orm imports @tina4/core (no CJS "exports" main).
+        // migration_status calls status(db)). Load orm via dynamic ESM import
+        // (the same mechanism server.ts uses for autoMigrateOnStartup) —
+        // reqSibling()'s createRequire fails here because @tina4/orm imports
+        // @tina4/core (no CJS "exports" main).
         const orm = await import("../../orm/src/index.js");
         if (typeof orm.status !== "function") {
           return { error: "Migration API not available (install @tina4/orm)" };
         }
-        const st = await orm.status(db, { migrationsDir: path.join(projectRoot, "migrations") });
+        // Pass the RAW adapter, NOT globalThis.__tina4_db. status()/migrate()
+        // read applied-state via adapterQuery -> adapter.query(); the Database
+        // WRAPPER has no .query/.queryAsync (only fetch/execute/tableExists), so
+        // passing it made adapterQuery throw, got swallowed, and every migration
+        // was reported "pending". getAdapter() is the same accessor the server
+        // boot (server.ts) and the CLI (commands/migrate.ts) pass — and it works.
+        let adapter;
+        try {
+          adapter = orm.getAdapter();
+        } catch {
+          return { error: "No database connection" };
+        }
+        const st = await orm.status(adapter, { migrationsDir: path.join(projectRoot, "migrations") });
         return { completed: st.completed, pending: st.pending };
       } catch (e) {
         return { error: (e as Error).message };
@@ -1422,17 +1464,26 @@ export function registerDevTools(server: McpServer): void {
     "migration_run",
     async (_args) => {
       try {
-        const db = (globalThis as any).__tina4_db;
-        if (!db) return { error: "No database connection" };
         // Run pending migrations for real (parity with the Python master's MCP
-        // migration_run -> Migration(db).migrate()). Previously a stub. Load orm
-        // via dynamic ESM import (server.ts's mechanism); reqSibling's createRequire
-        // fails because @tina4/orm imports @tina4/core.
+        // migration_run -> migrate(db)). Load orm via dynamic ESM import
+        // (server.ts's mechanism); reqSibling's createRequire fails because
+        // @tina4/orm imports @tina4/core.
         const orm = await import("../../orm/src/index.js");
         if (typeof orm.migrate !== "function") {
           return { error: "Migration API not available (install @tina4/orm)" };
         }
-        const result = await orm.migrate(db, { migrationsDir: path.join(projectRoot, "migrations") });
+        // Pass the RAW adapter, NOT globalThis.__tina4_db (see migration_status
+        // above). Passing the wrapper made migrate() unable to read applied-state
+        // (adapterQuery threw + was swallowed), so it re-applied every migration
+        // on every call — non-idempotent. With the raw adapter the second run
+        // reads passed=1 rows and skips them (idempotent).
+        let adapter;
+        try {
+          adapter = orm.getAdapter();
+        } catch {
+          return { error: "No database connection" };
+        }
+        const result = await orm.migrate(adapter, { migrationsDir: path.join(projectRoot, "migrations") });
         return { applied: result.applied, skipped: result.skipped, failed: result.failed };
       } catch (e) {
         return { error: (e as Error).message };
@@ -1585,12 +1636,44 @@ export function registerDevTools(server: McpServer): void {
     "seed_table",
     async (args) => {
       try {
-        const { seedTable } = reqSibling("orm") as { seedTable?: (db: unknown, table: string, count: number) => number | Promise<number> };
-        const db = (globalThis as any).__tina4_db;
-        if (!db) return { error: "No database connection" };
+        // Load orm via dynamic ESM import (NOT reqSibling/createRequire): the
+        // CJS require cache is a SEPARATE module instance from the ESM one that
+        // initDatabase() populated, so its getAdapter() sees a null adapter
+        // ("No database connection"). The migration tools already use await
+        // import for exactly this reason — share the live adapter.
+        const orm = await import("../../orm/src/index.js") as {
+          seedTable?: (db: unknown, table: string, count: number, fieldMap?: Record<string, () => unknown>) => Promise<{ seeded: number; failed: number }>;
+          autoFieldMap?: (db: unknown, table: string) => Promise<Record<string, () => unknown>>;
+          getAdapter?: () => unknown;
+        };
+        if (typeof orm.seedTable !== "function" || typeof orm.autoFieldMap !== "function") {
+          return { error: "Seeder API not available (install @tina4/orm)" };
+        }
+        // RAW adapter, NOT globalThis.__tina4_db: autoFieldMap introspects via
+        // adapter.columns() and seedTable inserts via adapter.execute() — the
+        // Database WRAPPER has neither (its introspection method is getColumns).
+        // getAdapter() is the same accessor migration_* use above.
+        let adapter;
+        try {
+          adapter = orm.getAdapter?.();
+        } catch {
+          return { error: "No database connection" };
+        }
+        if (!adapter) return { error: "No database connection" };
         const count = (args.count as number) || 10;
-        const inserted = (await seedTable?.(db, args.table as string, count)) ?? 0;
-        return { table: args.table, inserted };
+        // Build a column->generator map from the table's real columns (parity
+        // with Python's seed_table, which calls auto_field_map). seedTable with
+        // NO field map is a deliberate no-op (0 rows) — this is how a caller opts
+        // into automatic generation, so the tool must supply one or nothing
+        // inserts (the exact bug this fixes).
+        const fieldMap = await orm.autoFieldMap(adapter, args.table as string);
+        if (!fieldMap || Object.keys(fieldMap).length === 0) {
+          return { error: `Table '${args.table}' not found or has no seedable columns` };
+        }
+        const summary = await orm.seedTable(adapter, args.table as string, count, fieldMap);
+        // Return an INTEGER inserted count (Python shape {table, inserted}); the
+        // seeder returns a SeedSummary, so surface .seeded (+ .failed for context).
+        return { table: args.table, inserted: summary.seeded, failed: summary.failed };
       } catch (e) {
         return { error: (e as Error).message };
       }

package/packages/core/src/response.ts

@@ -52,7 +52,7 @@ export async function getFrond(): Promise<InstanceType<any>> {
   const dir = _defaultTemplatesDir ?? nodePath.resolve(process.cwd(), "src/templates");
   let engine = _frondCache.get(dir);
   if (!engine) {
-    const { Frond } = await import("@tina4/frond");
+    const { Frond } = await import("../../frond/src/engine.js");
     engine = new Frond(dir);
     _frondCache.set(dir, engine);
   }
@@ -68,7 +68,7 @@ export async function getFrameworkFrond(): Promise<InstanceType<any> | null> {
   const frameworkDir = nodePath.resolve(nodePath.dirname(import.meta.url.replace("file://", "")), "..", "templates");
   if (!_frameworkFrond && fs.existsSync(frameworkDir)) {
     try {
-      const { Frond } = await import("@tina4/frond");
+      const { Frond } = await import("../../frond/src/engine.js");
       _frameworkFrond = new Frond(frameworkDir);
     } catch { return null; }
   }
@@ -332,7 +332,7 @@ export function createResponse(res: ServerResponse): Tina4Response {
     templateDir?: string,
   ): Promise<Tina4Response> {
     try {
-      const { Frond } = await import("@tina4/frond");
+      const { Frond } = await import("../../frond/src/engine.js");
       const dir = templateDir ?? _defaultTemplatesDir ?? nodePath.resolve(process.cwd(), "src/templates");
       let engine = _frondCache.get(dir);
       if (!engine) {

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

@@ -56,6 +56,12 @@ const WIN_DRIVE_RE = /^\/?[A-Za-z]:[/\\]/;
  * slashes. Anything path-like is kept as a path.
  */
 export function normalizeFirebirdDbIdentifier(rawPath: string): string {
+  // php #160: a `?charset=` (or any query) tacked onto a connection URL must
+  // NOT leak into the Firebird database identifier — a path/alias never
+  // legitimately contains `?`. The charset itself is resolved separately by
+  // resolveFirebirdCharset(). Strip the query before decoding/normalising.
+  const queryIndex = rawPath.indexOf("?");
+  if (queryIndex >= 0) rawPath = rawPath.slice(0, queryIndex);
   let decoded = decodeURIComponent(rawPath);
 
   // Classic double-slash form: //abs/path -> /abs/path
@@ -87,6 +93,36 @@ export function normalizeFirebirdDbIdentifier(rawPath: string): string {
   return decoded.startsWith("/") ? decoded : "/" + decoded;
 }
 
+/**
+ * Resolve the Firebird connection charset (php #160 / parity with the Python
+ * master's `_resolve_firebird_charset`).
+ *
+ * The adapter used to pass NO charset, deferring to the driver's implicit
+ * default, which double-encodes UTF-8 bytes stored under a legacy `NONE`
+ * database. This resolves the charset from, in precedence order:
+ *
+ *   1. the connection URL query — `firebird://host:port/path?charset=NONE`
+ *   2. an explicit `charset` on the FirebirdConfig object passed to the adapter
+ *   3. the `TINA4_DATABASE_CHARSET` environment variable
+ *   4. the `UTF8` default
+ *
+ * Pure config resolution over its inputs (URL string, explicit charset, env) —
+ * it opens NO connection, so it is unit-testable without a live server.
+ */
+export function resolveFirebirdCharset(connectionString: string, explicitCharset?: string): string {
+  let urlCharset: string | undefined;
+  const queryIndex = (connectionString ?? "").indexOf("?");
+  if (queryIndex >= 0) {
+    urlCharset = new URLSearchParams(connectionString.slice(queryIndex + 1)).get("charset") ?? undefined;
+  }
+  return (
+    urlCharset ||
+    explicitCharset ||
+    process.env.TINA4_DATABASE_CHARSET ||
+    "UTF8"
+  );
+}
+
 export interface FirebirdConfig {
   host?: string;
   port?: number;
@@ -95,6 +131,8 @@ export interface FirebirdConfig {
   database?: string;
   role?: string;
   pageSize?: number;
+  /** Connection charset. Overridden by a `?charset=` URL query; see resolveFirebirdCharset. */
+  charset?: string;
 }
 
 export class FirebirdAdapter implements DatabaseAdapter {
@@ -120,6 +158,9 @@ export class FirebirdAdapter implements DatabaseAdapter {
         password: parsed.password ?? "masterkey",
         role: undefined,
         pageSize: 4096,
+        // php #160: honour ?charset= in the URL and TINA4_DATABASE_CHARSET so a
+        // legacy NONE database isn't force-connected under a mismatched charset.
+        charset: resolveFirebirdCharset(this.config),
       };
     } else {
       fbConfig = {
@@ -130,6 +171,8 @@ export class FirebirdAdapter implements DatabaseAdapter {
         password: this.config.password ?? "masterkey",
         role: this.config.role,
         pageSize: this.config.pageSize ?? 4096,
+        // php #160: explicit config.charset wins over env, else UTF8 default.
+        charset: resolveFirebirdCharset("", this.config.charset),
       };
     }
 
@@ -160,9 +203,10 @@ export class FirebirdAdapter implements DatabaseAdapter {
   }
 
   private parseUrl(url: string): { host?: string; port?: number; user?: string; password?: string; database?: string } {
-    // firebird://user:pass@host:port/path/to/db.fdb
+    // firebird://user:pass@host:port/path/to/db.fdb[?charset=...]
     // The path part after the host is normalised by normalizeFirebirdDbIdentifier()
-    // in connect(); here we just preserve it (with the leading "/" the regex strips).
+    // in connect() (which also strips any `?charset=` query — see php #160); here
+    // we just preserve it (with the leading "/" the regex strips).
     const match = url.match(/firebird:\/\/(?:([^:]+):([^@]+)@)?([^:/]+)(?::(\d+))?\/(.*)/);
     if (match) {
       return {

package/packages/orm/src/autoCrud.ts

@@ -1,4 +1,4 @@
-import type { RouteDefinition, Tina4Request, Tina4Response } from "@tina4/core";
+import type { RouteDefinition, Tina4Request, Tina4Response } from "../../core/src/index.js";
 import type { DiscoveredModel } from "./model.js";
 import { getAdapter, adapterQuery, adapterExecute } from "./database.js";
 import { buildQuery, parseQueryString } from "./query.js";

package/packages/orm/src/baseModel.ts

@@ -8,7 +8,7 @@ import { validate as validateFields } from "./validation.js";
 import { QueryBuilder } from "./queryBuilder.js";
 import { SQLiteAdapter } from "./adapters/sqlite.js";
 import { QueryCache } from "./sqlTranslation.js";
-import { Log } from "@tina4/core";
+import { Log } from "../../core/src/index.js";
 import type { DatabaseAdapter, FieldDefinition, RelationshipDefinition } from "./types.js";
 
 /**
@@ -701,23 +701,50 @@ export class BaseModel {
         await adapterExecute(db, `UPDATE "${ModelClass.tableName}" SET ${setClause} WHERE "${pkCol}" = ?`, values);
       } else {
         // Insert
+        //
+        // #165: an INSERT must OMIT a column the caller never assigned so a
+        // `NOT NULL DEFAULT <x>` column gets its DB default instead of an
+        // explicit NULL that violates the constraint. In TS an unset column is
+        // `undefined` (the constructor only seeds a field that declares a
+        // non-null ORM default — everything else stays `undefined`), so the
+        // `this[name] !== undefined` filter already drops unset columns; a
+        // value the caller set to `null` IS included and written as an explicit
+        // NULL (parity with Python's _assigned_fields split — JS distinguishes
+        // undefined-unset from null-explicit natively). A resolved non-null ORM
+        // default is still written (no regression).
         const insertFields = Object.entries(ModelClass.fields).filter(
           ([name, def]) => !(def.primaryKey && def.autoIncrement) && this[name] !== undefined,
         );
 
-        const columns = insertFields.map(([k]) => `"${ModelClass.getDbColumn(k)}"`).join(", ");
-        const placeholders = insertFields.map(() => "?").join(", ");
-        const values = insertFields.map(([k, def]) => toDbFieldValue(def, this[k]));
-
         // For auto-increment PKs on engines that need it (PostgreSQL),
         // RETURNING the PK column lets us read the engine-assigned id back.
         // SQLite ignores the RETURNING clause harmlessly (it supports it
         // since 3.35) and we still prefer its lastInsertRowid; for other
         // engines extractLastInsertId() reads rows[0].id.
         const wantReturning = pkField?.autoIncrement && db.constructor.name !== "SQLiteAdapter";
-        const insertSql =
-          `INSERT INTO "${ModelClass.tableName}" (${columns}) VALUES (${placeholders})` +
-          (wantReturning ? ` RETURNING "${pkCol}"` : "");
+        const returningClause = wantReturning ? ` RETURNING "${pkCol}"` : "";
+
+        let insertSql: string;
+        let values: unknown[];
+        if (insertFields.length === 0) {
+          // #165: every insertable column was left unset — let the DB apply ALL
+          // its column defaults rather than emitting an empty column list
+          // (`() VALUES ()` is invalid on SQLite/PostgreSQL/Firebird/MSSQL, which
+          // spell the all-defaults insert `DEFAULT VALUES`; only MySQL uses the
+          // empty-parens form). Mirrors the Python master's engine split.
+          insertSql =
+            (db.constructor.name === "MysqlAdapter"
+              ? `INSERT INTO "${ModelClass.tableName}" () VALUES ()`
+              : `INSERT INTO "${ModelClass.tableName}" DEFAULT VALUES`) + returningClause;
+          values = [];
+        } else {
+          const columns = insertFields.map(([k]) => `"${ModelClass.getDbColumn(k)}"`).join(", ");
+          const placeholders = insertFields.map(() => "?").join(", ");
+          values = insertFields.map(([k, def]) => toDbFieldValue(def, this[k]));
+          insertSql =
+            `INSERT INTO "${ModelClass.tableName}" (${columns}) VALUES (${placeholders})` +
+            returningClause;
+        }
 
         const result = await adapterExecute(db, insertSql, values);
 

package/packages/orm/src/cachedDatabase.ts

@@ -34,7 +34,7 @@
 
 import { QueryCache } from "./sqlTranslation.js";
 import type { DatabaseAdapter, DatabaseResult, ColumnInfo, FieldDefinition } from "./types.js";
-import type { CacheBackend } from "@tina4/core";
+import type { CacheBackend } from "../../core/src/index.js";
 
 function isTruthy(val: string | undefined): boolean {
   return ["true", "1", "yes", "on"].includes((val ?? "").trim().toLowerCase());
@@ -148,7 +148,7 @@ export class CachedDatabaseAdapter implements DatabaseAdapter {
         try {
           // Dynamic import keeps @tina4/orm free of an import-time cycle with
           // @tina4/core (whose `database` backend dynamically imports @tina4/orm).
-          const core: any = await import("@tina4/core");
+          const core: any = await import("../../core/src/index.js");
           const b: CacheBackend = await core.createBackend({
             backend: this.backendName,
             cacheUrl: process.env.TINA4_DB_CACHE_URL,

package/packages/orm/src/index.ts

@@ -57,7 +57,7 @@ export { SQLTranslator, QueryCache } from "./sqlTranslation.js";
 export { CachedDatabaseAdapter } from "./cachedDatabase.js";
 export type { CachedAdapterOptions } from "./cachedDatabase.js";
 export { FakeData } from "./fakeData.js";
-export { seedTable, seedOrm, seedModels } from "./seeder.js";
+export { seedTable, seedOrm, seedModels, autoFieldMap } from "./seeder.js";
 export type { SeedSummary, SeedOptions } from "./seeder.js";
 
 // DocStore — pymongo-style document store with a zero-config SQLite (JSON1) fallback
@@ -78,7 +78,7 @@ export { MysqlAdapter } from "./adapters/mysql.js";
 export type { MysqlConfig } from "./adapters/mysql.js";
 export { MssqlAdapter } from "./adapters/mssql.js";
 export type { MssqlConfig } from "./adapters/mssql.js";
-export { FirebirdAdapter, normalizeFirebirdDbIdentifier } from "./adapters/firebird.js";
+export { FirebirdAdapter, normalizeFirebirdDbIdentifier, resolveFirebirdCharset } from "./adapters/firebird.js";
 export type { FirebirdConfig } from "./adapters/firebird.js";
 export { MongodbAdapter } from "./adapters/mongodb.js";
 export type { MongoConfig } from "./adapters/mongodb.js";

package/packages/orm/src/migration.ts

@@ -1,6 +1,6 @@
 import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { Log } from "@tina4/core";
+import { Log } from "../../core/src/index.js";
 import type { FieldDefinition, DatabaseAdapter } from "./types.js";
 import type { SQLiteAdapter } from "./adapters/sqlite.js";
 import type { DiscoveredModel } from "./model.js";
@@ -1075,8 +1075,16 @@ export async function status(
     for (const row of rows) {
       if (row.migration_name) appliedNames.add(row.migration_name);
     }
-  } catch {
-    // No valid tracking — treat all as pending
+  } catch (err) {
+    // The tracking table exists (checked above) but reading applied-state
+    // failed — do NOT silently report every migration as pending. That
+    // masked a real bug: passing the Database WRAPPER (no .query) instead of a
+    // raw adapter made adapterQuery throw here, so status() reported all-pending
+    // and the MCP migration_run re-applied everything each call. Log loud so a
+    // wrong-arg / bad adapter can never again hide as "nothing applied yet".
+    // (Python master #57 "don't swallow" lesson.) Applied-state stays empty for
+    // this call, but the cause is now visible instead of masked.
+    Log.error(`Migration status: could not read applied migrations from "${MIGRATION_TABLE}" — ${(err as Error).message}`);
   }
 
   for (const file of files) {
@@ -1191,7 +1199,7 @@ export async function createClassMigration(
   const content =
     `// Migration: ${description}\n` +
     `// Created: ${now.toISOString()}\n\n` +
-    `import type { DatabaseAdapter } from "@tina4/orm";\n\n` +
+    `import type { DatabaseAdapter } from "tina4-nodejs/orm";\n\n` +
     `export class ${className} {\n` +
     `  async up(db: DatabaseAdapter): Promise<void> {\n` +
     `    // db.execute("CREATE TABLE ...");\n` +

package/packages/orm/src/realtime/realtime.ts

@@ -10,7 +10,7 @@ import {
   type WebSocketConnection,
   type Tina4Request,
   type Tina4Response,
-} from "@tina4/core";
+} from "../../../core/src/index.js";
 import Workspace from "./models/workspace.js";
 import Channel from "./models/channel.js";
 import ChannelMember from "./models/channelMember.js";

package/packages/orm/src/realtime/storage.ts

@@ -2,7 +2,7 @@ import { randomBytes } from "node:crypto";
 import { mkdirSync, readFileSync, writeFileSync, unlinkSync, statSync } from "node:fs";
 import { resolve, sep } from "node:path";
 import { createRequire } from "node:module";
-import { Log } from "@tina4/core";
+import { Log } from "../../../core/src/index.js";
 
 // ESM has no global `require`; create one so the OPTIONAL aws-sdk can be loaded
 // synchronously in S3Storage's constructor. A missing driver throws here and

package/packages/orm/src/seeder.ts

@@ -14,9 +14,9 @@
 //         real parent PKs, and warns on clear type mismatches.
 
 import { FakeData } from "./fakeData.js";
-import { adapterExecute, adapterFetch } from "./database.js";
-import { Log } from "@tina4/core";
-import type { DatabaseAdapter, FieldDefinition } from "./types.js";
+import { adapterExecute, adapterFetch, adapterColumns } from "./database.js";
+import { Log } from "../../core/src/index.js";
+import type { DatabaseAdapter, FieldDefinition, FieldType } from "./types.js";
 
 /**
  * Result of a seed run — `{ seeded, failed, errors }`.
@@ -75,6 +75,70 @@ async function clearTable(db: DatabaseAdapter, tableName: string): Promise<void>
   }
 }
 
+/**
+ * Map a raw SQL column type string to a Tina4 FieldType so FakeData.forField()
+ * can pick a generator. Substring match (case-insensitive) covers the engine
+ * spellings — INTEGER/INT, REAL/FLOAT/DOUBLE/NUMERIC/DECIMAL, BOOL, DATE/TIME,
+ * TEXT/CLOB. Anything else is a plain string.
+ */
+function sqlTypeToFieldType(sqlType: string): FieldType {
+  const t = (sqlType || "").toUpperCase();
+  if (t.includes("INT")) return "integer";
+  if (t.includes("BOOL")) return "boolean";
+  if (t.includes("REAL") || t.includes("FLOA") || t.includes("DOUB") || t.includes("NUM") || t.includes("DEC")) return "number";
+  if (t.includes("DATE") || t.includes("TIME")) return "datetime";
+  if (t.includes("TEXT") || t.includes("CLOB")) return "text";
+  return "string";
+}
+
+/**
+ * Introspect `table`'s columns and build a column->generator field map for
+ * {@link seedTable}, skipping the auto-increment / `id` primary key (the engine
+ * assigns it). Mirrors the Python master's `auto_field_map`
+ * (tina4_python/seeder/__init__.py): the shared "seed a table I did not
+ * hand-write generators for" helper that both the dev-admin seed endpoint and
+ * the MCP `seed_table` dev tool use — `seedTable` itself stays explicit
+ * (no map = no rows), and this is how a caller opts into automatic generation.
+ *
+ * Reuses `FakeData.forField()` (column-name + type heuristics) so the generated
+ * data matches every other Tina4 seeding path. Returns an empty map when the
+ * table has no seedable columns, so `seedTable` then seeds nothing rather than
+ * crashing.
+ *
+ * @param db - A DatabaseAdapter instance (pass `getAdapter()`, NOT the Database
+ *             wrapper — the wrapper has no `columns()`).
+ * @param table - The table to introspect.
+ * @param fake - Optional shared FakeData (pass one seeded via `new FakeData(n)`
+ *               for reproducible output).
+ * @returns `{ column -> () => value }`, ready to hand to `seedTable`.
+ */
+export async function autoFieldMap(
+  db: DatabaseAdapter,
+  table: string,
+  fake: FakeData = new FakeData(),
+): Promise<Record<string, () => unknown>> {
+  const columns = await adapterColumns(db, table);
+  const fieldMap: Record<string, () => unknown> = {};
+  for (const col of columns) {
+    const name = col.name;
+    const sqlType = String(col.type ?? "").toUpperCase();
+    // Skip the auto-increment surrogate key so the INSERT omits it and the
+    // engine assigns it. Mirrors Python: primary key AND (AUTO/SERIAL/IDENTITY
+    // in the type OR the column is literally `id` — SQLite reports just
+    // "INTEGER" for an AUTOINCREMENT rowid alias, so the name catch is needed).
+    if (col.primaryKey === true &&
+        (sqlType.includes("AUTO") || sqlType.includes("SERIAL") ||
+         sqlType.includes("IDENTITY") || name.toLowerCase() === "id")) {
+      continue;
+    }
+    const fieldType = sqlTypeToFieldType(sqlType);
+    // Bind the type + name per column; forField applies the name heuristics
+    // (email/phone/name/...) before falling back to the type.
+    fieldMap[name] = () => fake.forField({ type: fieldType }, name);
+  }
+  return fieldMap;
+}
+
 /**
  * Seed a database table with fake data using raw SQL inserts.
  *

package/packages/swagger/src/generator.ts

@@ -1,5 +1,5 @@
-import type { RouteDefinition } from "@tina4/core";
-import type { ModelDefinition, FieldDefinition } from "@tina4/orm";
+import type { RouteDefinition } from "../../core/src/index.js";
+import type { ModelDefinition, FieldDefinition } from "../../orm/src/index.js";
 
 interface OpenAPISpecInfo {
   title: string;

package/packages/swagger/src/ui.ts

@@ -1,4 +1,4 @@
-import type { Tina4Request, Tina4Response, RouteDefinition } from "@tina4/core";
+import type { Tina4Request, Tina4Response, RouteDefinition } from "../../core/src/index.js";
 
 // The UI assets load from a CDN by default (a documented architecture decision —
 // we don't vendor ~1.4MB of swagger-ui-dist, to stay small). Air-gapped