tina4-nodejs 3.8.5 → 3.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tina4-nodejs",
-  "version": "3.8.5",
+  "version": "3.9.0",
   "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"],

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/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/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.");
+      }
+    }
+  }
+}