tina4-nodejs 3.13.11 → 3.13.14

package/CLAUDE.md

@@ -1,10 +1,10 @@
-# CLAUDE.md — AI Developer Guide for tina4-nodejs (v3.13.11)
+# CLAUDE.md — AI Developer Guide for tina4-nodejs (v3.13.14)
 
 > 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.11 — 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.14 — 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.
 

package/package.json

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

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/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;
   }
 

package/packages/orm/src/database.ts

@@ -2,6 +2,26 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import type { DatabaseAdapter, DatabaseResult as DatabaseWriteResult } from "./types.js";
 import { DatabaseResult } from "./databaseResult.js";
 
+/**
+ * v3.13.12 — strip trailing `;` and whitespace from user-supplied SQL
+ * before the framework wraps it with COUNT(*) subqueries or appends
+ * LIMIT/OFFSET clauses. Without this, `"SELECT * FROM t;"` becomes
+ * `"SELECT * FROM t; LIMIT 100 OFFSET 0"` — a syntax error on every
+ * engine. Internal semicolons (in string literals, between meaningful
+ * statements) are left alone; drivers reject those if the engine
+ * doesn't support multi-statement.
+ *
+ * Exported so adapters and external tooling can compose it.
+ */
+export function stripTrailingSemicolons(sql: string): string {
+  if (!sql) return sql;
+  let stripped = sql.replace(/\s+$/, "");
+  while (stripped.endsWith(";")) {
+    stripped = stripped.slice(0, -1).replace(/\s+$/, "");
+  }
+  return stripped;
+}
+
 let activeAdapter: DatabaseAdapter | null = null;
 const namedAdapters: Map<string, DatabaseAdapter> = new Map();
 
@@ -404,6 +424,10 @@ export class Database {
 
   /** Query rows with optional pagination. Returns a DatabaseResult wrapper. */
   fetch(sql: string, params?: unknown[], limit?: number, offset?: number): DatabaseResult {
+    // v3.13.12: strip trailing `;` before the adapter wraps with COUNT(*)
+    // or appends LIMIT/OFFSET. Without this, `"SELECT * FROM t;"` becomes
+    // `"SELECT * FROM t; LIMIT 100 OFFSET 0"` — a syntax error.
+    sql = stripTrailingSemicolons(sql);
     const adapter = this.getNextAdapter();
     const rows = adapter.fetch<Record<string, unknown>>(sql, params, limit, offset);
     return new DatabaseResult(rows, undefined, undefined, limit, offset, adapter, sql);
@@ -411,6 +435,7 @@ export class Database {
 
   /** Fetch a single row or null. */
   fetchOne<T = Record<string, unknown>>(sql: string, params?: unknown[]): T | null {
+    sql = stripTrailingSemicolons(sql);
     return this.getNextAdapter().fetchOne<T>(sql, params);
   }
 

package/packages/orm/src/index.ts

@@ -14,7 +14,7 @@ export { FetchResult } from "./types.js";
 
 export { DatabaseResult } from "./databaseResult.js";
 export type { ColumnInfoResult } from "./databaseResult.js";
-export { Database, initDatabase, getAdapter, setAdapter, closeDatabase, parseDatabaseUrl, setNamedAdapter, getNamedAdapter, resolveDbPool } from "./database.js";
+export { Database, initDatabase, getAdapter, setAdapter, closeDatabase, parseDatabaseUrl, setNamedAdapter, getNamedAdapter, resolveDbPool, stripTrailingSemicolons } from "./database.js";
 export type { DatabaseConfig, ParsedDatabaseUrl } from "./database.js";
 export { discoverModels } from "./model.js";
 export type { DiscoveredModel } from "./model.js";

package/packages/orm/src/sqlTranslation.ts

@@ -156,6 +156,22 @@ export class SQLTranslator {
       columns,
     };
   }
+
+  /**
+   * v3.13.14 (#48): split a possibly-qualified table name into [schema, table].
+   *
+   * A model whose table name is qualified — PostgreSQL "gift_cards.gift_card",
+   * MSSQL "dbo.widget", MySQL "otherdb.table", SQLite "attached.table" — lives
+   * in that schema/catalog, not the default. Adapters use this so tableExists /
+   * getColumns query the right namespace instead of matching the whole dotted
+   * string as one flat name. Returns [null, name] for a bare name. Splits on the
+   * first dot. Firebird has no schemas, so its adapter ignores this.
+   */
+  static splitSchema(name: string): [string | null, string] {
+    const idx = name.indexOf(".");
+    if (idx === -1) return [null, name];
+    return [name.slice(0, idx), name.slice(idx + 1)];
+  }
 }
 
 // ── Query Cache ──────────────────────────────────────────────