tina4-nodejs 3.8.4 → 3.8.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tina4-nodejs",
-  "version": "3.8.4",
+  "version": "3.8.7",
   "type": "module",
   "description": "This is not a framework. Tina4 for Node.js/TypeScript — zero deps, 38 built-in features.",
   "keywords": ["tina4", "framework", "web", "api", "orm", "graphql", "websocket", "typescript"],
@@ -49,9 +49,7 @@
   "engines": {
     "node": ">=20.0.0"
   },
-  "dependencies": {
-    "better-sqlite3": "^11.0.0"
-  },
+  "dependencies": {},
   "devDependencies": {
     "typescript": "^5.7.0",
     "tsx": "^4.19.0",

package/packages/core/src/server.ts

@@ -568,6 +568,28 @@ ${reset}
     const req = createRequest(rawReq);
     const res = createResponse(rawRes);
 
+    // Auto-start session — read cookie, create session, save + set cookie on response end
+    {
+      const { Session } = await import("./session.js");
+      const cookieHeader = rawReq.headers.cookie ?? "";
+      const sidMatch = cookieHeader.match(/tina4_session=([^;]+)/);
+      const existingSid = sidMatch ? sidMatch[1] : undefined;
+      const sess = new Session();
+      sess.start(existingSid);
+      (req as any).session = sess;
+
+      const origEnd = rawRes.end.bind(rawRes);
+      rawRes.end = function (...args: any[]) {
+        sess.save();
+        const newSid = (sess as any).sessionId ?? (sess as any).getSessionId?.();
+        if (newSid && newSid !== existingSid && !rawRes.headersSent) {
+          const ttl = parseInt(process.env.TINA4_SESSION_TTL ?? "3600", 10);
+          rawRes.setHeader("Set-Cookie", `tina4_session=${newSid}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${ttl}`);
+        }
+        return origEnd(...args);
+      } as typeof rawRes.end;
+    }
+
     // Add res.render() if Frond is available
     if (frondEngine) {
       res.render = (template: string, data?: Record<string, unknown>, statusCode?: number) => {
@@ -661,20 +683,23 @@ ${reset}
           if (!proceed || res.raw.writableEnded) return;
         }
 
-        // Support (), (response), (request), or (request, response) handler signatures
-        // When 1 param: if named request/req, pass request; otherwise pass response
+        // Inject path params by name into handler arguments, then request/response
         let result: unknown;
-        if (match.handler.length === 0) {
+        const routeParams = req.params || {};
+        const fnStr = match.handler.toString();
+        const argMatch = fnStr.match(/^(?:async\s+)?(?:function\s*\w*)?\s*\(([^)]*)\)/);
+        const argNames = argMatch?.[1]?.split(",").map((s: string) => s.trim().replace(/[:=].*/,"")) ?? [];
+        const filteredArgs = argNames.filter((n: string) => n.length > 0);
+
+        if (filteredArgs.length === 0) {
           result = await (match.handler as any)();
-        } else if (match.handler.length === 1) {
-          const fnStr = match.handler.toString();
-          const paramMatch = fnStr.match(/^(?:async\s+)?(?:function\s*)?\(?\s*(\w+)/);
-          const paramName = paramMatch?.[1]?.toLowerCase() ?? "";
-          result = (paramName === "request" || paramName === "req")
-            ? await match.handler(req as any)
-            : await match.handler(res as any);
         } else {
-          result = await match.handler(req, res);
+          const args = filteredArgs.map((name: string) => {
+            if (name in routeParams) return routeParams[name];
+            if (name === "request" || name === "req") return req;
+            return res;
+          });
+          result = await (match.handler as any)(...args);
         }
 
         // If the route exports a template and the handler returned a plain object,

package/packages/core/src/sessionHandlers/databaseHandler.ts

@@ -39,18 +39,9 @@ export class DatabaseSessionHandler implements SessionHandler {
   constructor(config?: DatabaseSessionConfig) {
     const dbPath = config?.dbPath ?? this.resolveDbPath();
 
-    let Database: any;
-    try {
-      Database = _require("better-sqlite3");
-    } catch {
-      throw new Error(
-        "DatabaseSessionHandler requires 'better-sqlite3'. " +
-        "Install it with: npm install better-sqlite3"
-      );
-    }
-
-    this.db = new Database(dbPath);
-    this.db.pragma("journal_mode = WAL");
+    const { DatabaseSync } = require("node:sqlite");
+    this.db = new DatabaseSync(dbPath);
+    this.db.exec("PRAGMA journal_mode = WAL");
   }
 
   /**

package/packages/core/src/types.ts

@@ -8,12 +8,22 @@ export interface UploadedFile {
   size: number;
 }
 
+export interface Tina4Session {
+  get(key: string, defaultValue?: unknown): unknown;
+  set(key: string, value: unknown): void;
+  delete(key: string): void;
+  clear(): void;
+  save(): void;
+  readonly id: string;
+}
+
 export interface Tina4Request extends IncomingMessage {
   params: Record<string, string>;
   query: Record<string, string>;
   body: unknown;
   ip: string;
   files: UploadedFile[];
+  session: Tina4Session;
 }
 
 export interface CookieOptions {

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

@@ -1,19 +1,19 @@
-import Database from "better-sqlite3";
+import { DatabaseSync } from "node:sqlite";
 import { mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 import type { DatabaseAdapter, DatabaseResult, ColumnInfo, FieldDefinition } from "../types.js";
 
 export class SQLiteAdapter implements DatabaseAdapter {
-  private db: Database.Database;
+  private db: DatabaseSync;
   private _lastInsertId: number | bigint | null = null;
 
   constructor(dbPath: string) {
-    // Create directory if needed
-    mkdirSync(dirname(dbPath), { recursive: true });
-
-    this.db = new Database(dbPath);
-    this.db.pragma("journal_mode = WAL");
-    this.db.pragma("foreign_keys = ON");
+    if (dbPath !== ":memory:") {
+      mkdirSync(dirname(dbPath), { recursive: true });
+    }
+    this.db = new DatabaseSync(dbPath);
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec("PRAGMA foreign_keys = ON");
   }
 
   execute(sql: string, params?: unknown[]): unknown {
@@ -30,8 +30,9 @@ export class SQLiteAdapter implements DatabaseAdapter {
     let totalAffected = 0;
     let lastId: number | bigint | undefined;
 
-    const runMany = this.db.transaction((rows: unknown[][]) => {
-      for (const params of rows) {
+    this.db.exec("BEGIN TRANSACTION");
+    try {
+      for (const params of paramsList) {
         const result = stmt.run(...params);
         totalAffected += result.changes;
         if (result.lastInsertRowid) {
@@ -39,9 +40,12 @@ export class SQLiteAdapter implements DatabaseAdapter {
           this._lastInsertId = result.lastInsertRowid;
         }
       }
-    });
+      this.db.exec("COMMIT");
+    } catch (e) {
+      this.db.exec("ROLLBACK");
+      throw e;
+    }
 
-    runMany(paramsList);
     return { totalAffected, lastInsertId: lastId };
   }
 
@@ -68,7 +72,6 @@ export class SQLiteAdapter implements DatabaseAdapter {
   }
 
   insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): DatabaseResult {
-    // Handle list of rows — batch insert
     if (Array.isArray(data)) {
       if (data.length === 0) return { success: true, rowsAffected: 0 };
       const keys = Object.keys(data[0]);
@@ -87,17 +90,9 @@ export class SQLiteAdapter implements DatabaseAdapter {
     try {
       const result = this.db.prepare(sql).run(...values);
       this._lastInsertId = result.lastInsertRowid;
-      return {
-        success: true,
-        rowsAffected: result.changes,
-        lastInsertId: result.lastInsertRowid,
-      };
+      return { success: true, rowsAffected: result.changes, lastInsertId: result.lastInsertRowid };
     } catch (e) {
-      return {
-        success: false,
-        rowsAffected: 0,
-        error: (e as Error).message,
-      };
+      return { success: false, rowsAffected: 0, error: (e as Error).message };
     }
   }
 
@@ -116,7 +111,6 @@ export class SQLiteAdapter implements DatabaseAdapter {
   }
 
   delete(table: string, filter: Record<string, unknown> | string | Record<string, unknown>[]): DatabaseResult {
-    // Array of objects — delete each row
     if (Array.isArray(filter)) {
       let totalAffected = 0;
       for (const row of filter) {
@@ -126,7 +120,6 @@ export class SQLiteAdapter implements DatabaseAdapter {
       return { success: true, rowsAffected: totalAffected };
     }
 
-    // String filter — raw WHERE clause
     if (typeof filter === "string") {
       const sql = filter ? `DELETE FROM "${table}" WHERE ${filter}` : `DELETE FROM "${table}"`;
       try {
@@ -137,7 +130,6 @@ export class SQLiteAdapter implements DatabaseAdapter {
       }
     }
 
-    // Object filter — build WHERE from keys
     const whereClauses = Object.keys(filter).map((k) => `"${k}" = ?`).join(" AND ");
     const sql = `DELETE FROM "${table}" WHERE ${whereClauses}`;
     const values = Object.values(filter);
@@ -150,17 +142,9 @@ export class SQLiteAdapter implements DatabaseAdapter {
     }
   }
 
-  startTransaction(): void {
-    this.db.exec("BEGIN TRANSACTION");
-  }
-
-  commit(): void {
-    this.db.exec("COMMIT");
-  }
-
-  rollback(): void {
-    this.db.exec("ROLLBACK");
-  }
+  startTransaction(): void { this.db.exec("BEGIN TRANSACTION"); }
+  commit(): void { this.db.exec("COMMIT"); }
+  rollback(): void { this.db.exec("ROLLBACK"); }
 
   tables(): string[] {
     const rows = this.query<{ name: string }>(
@@ -171,95 +155,57 @@ export class SQLiteAdapter implements DatabaseAdapter {
 
   columns(table: string): ColumnInfo[] {
     const rows = this.db.prepare(`PRAGMA table_info("${table}")`).all() as Array<{
-      name: string;
-      type: string;
-      notnull: number;
-      dflt_value: unknown;
-      pk: number;
+      name: string; type: string; notnull: number; dflt_value: unknown; pk: number;
     }>;
     return rows.map((r) => ({
-      name: r.name,
-      type: r.type,
-      nullable: r.notnull === 0,
-      default: r.dflt_value,
-      primaryKey: r.pk === 1,
+      name: r.name, type: r.type, nullable: r.notnull === 0, default: r.dflt_value, primaryKey: r.pk === 1,
     }));
   }
 
-  lastInsertId(): number | bigint | null {
-    return this._lastInsertId;
-  }
-
-  close(): void {
-    this.db.close();
-  }
+  lastInsertId(): number | bigint | null { return this._lastInsertId; }
+  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);
+    const result = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(name);
     return !!result;
   }
 
   createTable(name: string, columns: Record<string, FieldDefinition>): void {
     const colDefs: string[] = [];
-
     for (const [colName, def] of Object.entries(columns)) {
       const sqlType = fieldTypeToSQLite(def.type);
       const parts = [`"${colName}" ${sqlType}`];
-
       if (def.primaryKey) parts.push("PRIMARY KEY");
       if (def.autoIncrement) parts.push("AUTOINCREMENT");
       if (def.required && !def.primaryKey) parts.push("NOT NULL");
-      if (def.default !== undefined && def.default !== "now") {
-        parts.push(`DEFAULT ${sqlDefault(def.default)}`);
-      }
-      if (def.default === "now") {
-        parts.push("DEFAULT CURRENT_TIMESTAMP");
-      }
-
+      if (def.default !== undefined && def.default !== "now") parts.push(`DEFAULT ${sqlDefault(def.default)}`);
+      if (def.default === "now") parts.push("DEFAULT CURRENT_TIMESTAMP");
       colDefs.push(parts.join(" "));
     }
-
-    const sql = `CREATE TABLE IF NOT EXISTS "${name}" (${colDefs.join(", ")})`;
-    this.db.exec(sql);
+    this.db.exec(`CREATE TABLE IF NOT EXISTS "${name}" (${colDefs.join(", ")})`);
   }
 
   getTableColumns(name: string): Array<{ name: string; type: string }> {
-    return this.db.prepare(`PRAGMA table_info("${name}")`).all() as Array<{
-      name: string;
-      type: string;
-    }>;
+    return this.db.prepare(`PRAGMA table_info("${name}")`).all() as Array<{ name: string; type: string }>;
   }
 
   addColumn(table: string, colName: string, def: FieldDefinition): void {
     const sqlType = fieldTypeToSQLite(def.type);
     let sql = `ALTER TABLE "${table}" ADD COLUMN "${colName}" ${sqlType}`;
-    if (def.default !== undefined && def.default !== "now") {
-      sql += ` DEFAULT ${sqlDefault(def.default)}`;
-    } else if (def.default === "now") {
-      sql += " DEFAULT CURRENT_TIMESTAMP";
-    }
+    if (def.default !== undefined && def.default !== "now") sql += ` DEFAULT ${sqlDefault(def.default)}`;
+    else if (def.default === "now") sql += " DEFAULT CURRENT_TIMESTAMP";
     this.db.exec(sql);
   }
 }
 
 function fieldTypeToSQLite(type: string): string {
   switch (type) {
-    case "integer":
-      return "INTEGER";
-    case "number":
-    case "numeric":
-      return "REAL";
-    case "boolean":
-      return "INTEGER";
-    case "datetime":
-      return "TEXT";
-    case "text":
-      return "TEXT";
-    case "string":
-    default:
-      return "TEXT";
+    case "integer": return "INTEGER";
+    case "number": case "numeric": return "REAL";
+    case "boolean": return "INTEGER";
+    case "datetime": return "TEXT";
+    case "text": return "TEXT";
+    case "string": default: return "TEXT";
   }
 }
 

package/packages/orm/src/baseModel.ts

@@ -1,5 +1,6 @@
 import { getAdapter, getNamedAdapter } from "./database.js";
 import { validate as validateFields } from "./validation.js";
+import { QueryBuilder } from "./queryBuilder.js";
 import type { DatabaseAdapter, FieldDefinition, RelationshipDefinition } from "./types.js";
 
 /**
@@ -90,6 +91,18 @@ export class BaseModel {
     return reverse;
   }
 
+  /**
+   * Create a fluent QueryBuilder pre-configured for this model's table and database.
+   *
+   * Usage:
+   *   const results = User.query().where("active = ?", [1]).orderBy("name").get();
+   *
+   * @returns A QueryBuilder instance bound to this model's table and database.
+   */
+  static query(): QueryBuilder {
+    return QueryBuilder.from(this.tableName, this.getDb());
+  }
+
   /**
    * Get the database adapter for this model.
    */

package/packages/orm/src/index.ts

@@ -39,6 +39,7 @@ export { buildQuery, parseQueryString } from "./query.js";
 export { validate } from "./validation.js";
 export type { ValidationError } from "./validation.js";
 export { BaseModel } from "./baseModel.js";
+export { QueryBuilder } from "./queryBuilder.js";
 export { SQLTranslator, QueryCache } from "./sqlTranslation.js";
 export { CachedDatabaseAdapter } from "./cachedDatabase.js";
 export { FakeData } from "./fakeData.js";

package/packages/orm/src/queryBuilder.ts

@@ -0,0 +1,299 @@
+/**
+ * QueryBuilder — Fluent SQL query builder for Tina4 Node.js.
+ *
+ * Usage:
+ *   // Standalone
+ *   const result = QueryBuilder.from("users", db)
+ *     .select("id", "name")
+ *     .where("active = ?", [1])
+ *     .orderBy("name ASC")
+ *     .limit(10)
+ *     .get();
+ *
+ *   // From ORM model
+ *   const result = User.query()
+ *     .where("age > ?", [18])
+ *     .orderBy("name")
+ *     .get();
+ */
+
+import type { DatabaseAdapter } from "./types.js";
+import { getAdapter } from "./database.js";
+
+export class QueryBuilder {
+  private table: string;
+  private db: DatabaseAdapter | undefined;
+  private columns: string[] = ["*"];
+  private wheres: [string, string][] = [];
+  private params: unknown[] = [];
+  private joinClauses: string[] = [];
+  private groupByCols: string[] = [];
+  private havings: string[] = [];
+  private havingParams: unknown[] = [];
+  private orderByCols: string[] = [];
+  private limitVal: number | undefined;
+  private offsetVal: number | undefined;
+
+  /**
+   * Private constructor — use static factory methods.
+   */
+  private constructor(table: string, db?: DatabaseAdapter) {
+    this.table = table;
+    this.db = db;
+  }
+
+  /**
+   * Create a QueryBuilder for a table.
+   *
+   * @param tableName - Table name.
+   * @param db - Optional database adapter.
+   * @returns A new QueryBuilder instance.
+   */
+  static from(tableName: string, db?: DatabaseAdapter): QueryBuilder {
+    return new QueryBuilder(tableName, db);
+  }
+
+  /**
+   * Set the columns to select.
+   *
+   * @param cols - Column names.
+   * @returns this for chaining.
+   */
+  select(...cols: string[]): QueryBuilder {
+    if (cols.length > 0) {
+      this.columns = cols;
+    }
+    return this;
+  }
+
+  /**
+   * Add a WHERE condition (AND).
+   *
+   * @param condition - SQL condition with ? placeholders.
+   * @param params - Parameter values.
+   * @returns this for chaining.
+   */
+  where(condition: string, params: unknown[] = []): QueryBuilder {
+    this.wheres.push(["AND", condition]);
+    this.params.push(...params);
+    return this;
+  }
+
+  /**
+   * Add a WHERE condition (OR).
+   *
+   * @param condition - SQL condition with ? placeholders.
+   * @param params - Parameter values.
+   * @returns this for chaining.
+   */
+  orWhere(condition: string, params: unknown[] = []): QueryBuilder {
+    this.wheres.push(["OR", condition]);
+    this.params.push(...params);
+    return this;
+  }
+
+  /**
+   * Add an INNER JOIN.
+   *
+   * @param table - Table to join.
+   * @param onClause - Join condition.
+   * @returns this for chaining.
+   */
+  join(table: string, onClause: string): QueryBuilder {
+    this.joinClauses.push(`INNER JOIN ${table} ON ${onClause}`);
+    return this;
+  }
+
+  /**
+   * Add a LEFT JOIN.
+   *
+   * @param table - Table to join.
+   * @param onClause - Join condition.
+   * @returns this for chaining.
+   */
+  leftJoin(table: string, onClause: string): QueryBuilder {
+    this.joinClauses.push(`LEFT JOIN ${table} ON ${onClause}`);
+    return this;
+  }
+
+  /**
+   * Add a GROUP BY column.
+   *
+   * @param column - Column name.
+   * @returns this for chaining.
+   */
+  groupBy(column: string): QueryBuilder {
+    this.groupByCols.push(column);
+    return this;
+  }
+
+  /**
+   * Add a HAVING clause.
+   *
+   * @param expression - HAVING expression with ? placeholders.
+   * @param params - Parameter values.
+   * @returns this for chaining.
+   */
+  having(expression: string, params: unknown[] = []): QueryBuilder {
+    this.havings.push(expression);
+    this.havingParams.push(...params);
+    return this;
+  }
+
+  /**
+   * Add an ORDER BY clause.
+   *
+   * @param expression - Column and direction (e.g. "name ASC").
+   * @returns this for chaining.
+   */
+  orderBy(expression: string): QueryBuilder {
+    this.orderByCols.push(expression);
+    return this;
+  }
+
+  /**
+   * Set LIMIT and optional OFFSET.
+   *
+   * @param count - Maximum rows to return.
+   * @param offset - Number of rows to skip.
+   * @returns this for chaining.
+   */
+  limit(count: number, offset?: number): QueryBuilder {
+    this.limitVal = count;
+    if (offset !== undefined) {
+      this.offsetVal = offset;
+    }
+    return this;
+  }
+
+  /**
+   * Build and return the SQL string without executing.
+   *
+   * @returns The constructed SQL query.
+   */
+  toSql(): string {
+    let sql = `SELECT ${this.columns.join(", ")} FROM ${this.table}`;
+
+    if (this.joinClauses.length > 0) {
+      sql += " " + this.joinClauses.join(" ");
+    }
+
+    if (this.wheres.length > 0) {
+      sql += " WHERE " + this.buildWhere();
+    }
+
+    if (this.groupByCols.length > 0) {
+      sql += " GROUP BY " + this.groupByCols.join(", ");
+    }
+
+    if (this.havings.length > 0) {
+      sql += " HAVING " + this.havings.join(" AND ");
+    }
+
+    if (this.orderByCols.length > 0) {
+      sql += " ORDER BY " + this.orderByCols.join(", ");
+    }
+
+    return sql;
+  }
+
+  /**
+   * Execute the query and return all matching rows.
+   *
+   * @returns Array of row objects.
+   */
+  get<T = Record<string, unknown>>(): T[] {
+    this.ensureDb();
+    const sql = this.toSql();
+    const allParams = [...this.params, ...this.havingParams];
+
+    return this.db!.fetch<T>(
+      sql,
+      allParams.length > 0 ? allParams : undefined,
+      this.limitVal,
+      this.offsetVal,
+    );
+  }
+
+  /**
+   * Execute the query and return a single row.
+   *
+   * @returns A single row object, or null.
+   */
+  first<T = Record<string, unknown>>(): T | null {
+    this.ensureDb();
+    const sql = this.toSql();
+    const allParams = [...this.params, ...this.havingParams];
+
+    return this.db!.fetchOne<T>(
+      sql,
+      allParams.length > 0 ? allParams : undefined,
+    );
+  }
+
+  /**
+   * Execute the query and return the row count.
+   *
+   * @returns Number of matching rows.
+   */
+  count(): number {
+    this.ensureDb();
+
+    // Build a count query by replacing columns
+    const original = this.columns;
+    this.columns = ["COUNT(*) as cnt"];
+    const sql = this.toSql();
+    this.columns = original;
+
+    const allParams = [...this.params, ...this.havingParams];
+
+    const row = this.db!.fetchOne<Record<string, unknown>>(
+      sql,
+      allParams.length > 0 ? allParams : undefined,
+    );
+
+    if (!row) return 0;
+
+    // Handle case-insensitive column names
+    const cnt = row["cnt"] ?? row["CNT"] ?? 0;
+    return Number(cnt);
+  }
+
+  /**
+   * Check whether any matching rows exist.
+   *
+   * @returns True if at least one row matches.
+   */
+  exists(): boolean {
+    return this.count() > 0;
+  }
+
+  /**
+   * Build the WHERE clause from accumulated conditions.
+   */
+  private buildWhere(): string {
+    const parts: string[] = [];
+    for (let i = 0; i < this.wheres.length; i++) {
+      const [connector, condition] = this.wheres[i];
+      if (i === 0) {
+        parts.push(condition);
+      } else {
+        parts.push(`${connector} ${condition}`);
+      }
+    }
+    return parts.join(" ");
+  }
+
+  /**
+   * Ensure a database adapter is available.
+   */
+  private ensureDb(): void {
+    if (!this.db) {
+      try {
+        this.db = getAdapter();
+      } catch {
+        throw new Error("QueryBuilder: No database adapter provided.");
+      }
+    }
+  }
+}