tina4-nodejs 3.10.34 → 3.10.40

package/packages/core/src/response.ts

@@ -3,6 +3,20 @@ import fs from "node:fs";
 import nodePath from "node:path";
 import type { Tina4Response, CookieOptions } from "./types.js";
 
+/** Cache Frond instances by template directory to avoid repeated instantiation. */
+const _frondCache = new Map<string, InstanceType<any>>();
+
+/** Default templates directory — set via setDefaultTemplatesDir(). */
+let _defaultTemplatesDir: string | null = null;
+
+/**
+ * Set the default templates directory for render()/template().
+ * Called by server.ts during startup.
+ */
+export function setDefaultTemplatesDir(dir: string): void {
+  _defaultTemplatesDir = dir;
+}
+
 /**
  * Creates a callable response object.
  *
@@ -16,42 +30,52 @@ import type { Tina4Response, CookieOptions } from "./types.js";
  */
 export function createResponse(res: ServerResponse): Tina4Response {
 
+  // ── Guard: prevent writing after headers are sent ──
+  const safeEnd = (...args: Parameters<typeof res.end>) => {
+    if (!res.headersSent) (res.end as Function)(...args);
+  };
+  const safeSetHeader = (name: string, value: string | number | readonly string[]) => {
+    if (!res.headersSent) res.setHeader(name, value);
+  };
+
   // ── The callable: response(data, status, contentType) ──
   const response = function (data?: unknown, statusCode?: number, contentType?: string): Tina4Response {
+    if (res.headersSent) return response;
+
     if (statusCode !== undefined) {
       res.statusCode = statusCode;
     }
 
     if (contentType) {
       // Explicit content type
-      res.setHeader("Content-Type", contentType);
+      safeSetHeader("Content-Type", contentType);
       if (typeof data === "object" && data !== null && !Buffer.isBuffer(data)) {
-        res.end(JSON.stringify(data));
+        safeEnd(JSON.stringify(data));
       } else {
-        res.end(data == null ? "" : String(data));
+        safeEnd(data == null ? "" : String(data));
       }
     } else if (typeof data === "object" && data !== null && !Buffer.isBuffer(data)) {
       // dict/array → auto JSON
-      res.setHeader("Content-Type", "application/json");
-      res.end(JSON.stringify(data));
+      safeSetHeader("Content-Type", "application/json");
+      safeEnd(JSON.stringify(data));
     } else if (typeof data === "string") {
       const trimmed = data.trim();
       if (trimmed.startsWith("<") && trimmed.endsWith(">")) {
-        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        safeSetHeader("Content-Type", "text/html; charset=utf-8");
       } else {
-        res.setHeader("Content-Type", "text/plain; charset=utf-8");
+        safeSetHeader("Content-Type", "text/plain; charset=utf-8");
       }
-      res.end(data);
+      safeEnd(data);
     } else if (Buffer.isBuffer(data)) {
       if (!res.getHeader("Content-Type")) {
-        res.setHeader("Content-Type", "application/octet-stream");
+        safeSetHeader("Content-Type", "application/octet-stream");
       }
-      res.end(data);
+      safeEnd(data);
     } else if (data == null) {
-      res.end("");
+      safeEnd("");
     } else {
-      res.setHeader("Content-Type", "text/plain; charset=utf-8");
-      res.end(String(data));
+      safeSetHeader("Content-Type", "text/plain; charset=utf-8");
+      safeEnd(String(data));
     }
 
     return response;
@@ -63,23 +87,26 @@ export function createResponse(res: ServerResponse): Tina4Response {
   // ── Explicit methods ──
 
   response.json = function (data: unknown, status?: number): Tina4Response {
+    if (res.headersSent) return response;
     if (status !== undefined) res.statusCode = status;
-    res.setHeader("Content-Type", "application/json");
-    res.end(JSON.stringify(data));
+    safeSetHeader("Content-Type", "application/json");
+    safeEnd(JSON.stringify(data));
     return response;
   };
 
   response.html = function (content: string, status?: number): Tina4Response {
+    if (res.headersSent) return response;
     if (status !== undefined) res.statusCode = status;
-    res.setHeader("Content-Type", "text/html; charset=utf-8");
-    res.end(content);
+    safeSetHeader("Content-Type", "text/html; charset=utf-8");
+    safeEnd(content);
     return response;
   };
 
   response.text = function (content: string, status?: number): Tina4Response {
+    if (res.headersSent) return response;
     if (status !== undefined) res.statusCode = status;
-    res.setHeader("Content-Type", "text/plain; charset=utf-8");
-    res.end(content);
+    safeSetHeader("Content-Type", "text/plain; charset=utf-8");
+    safeEnd(content);
     return response;
   };
 
@@ -88,19 +115,20 @@ export function createResponse(res: ServerResponse): Tina4Response {
   };
 
   response.status = function (code: number): Tina4Response {
-    res.statusCode = code;
+    if (!res.headersSent) res.statusCode = code;
     return response;
   };
 
   response.header = function (name: string, value: string | number | readonly string[]): Tina4Response {
-    res.setHeader(name, value);
+    safeSetHeader(name, value);
     return response;
   };
 
   response.redirect = function (url: string, code?: number): Tina4Response {
+    if (res.headersSent) return response;
     res.statusCode = code ?? 302;
-    res.setHeader("Location", url);
-    res.end();
+    safeSetHeader("Location", url);
+    safeEnd();
     return response;
   };
 
@@ -119,7 +147,7 @@ export function createResponse(res: ServerResponse): Tina4Response {
     if (Array.isArray(existing)) cookies.push(...(existing as string[]));
     else if (typeof existing === "string") cookies.push(existing);
     cookies.push(parts.join("; "));
-    res.setHeader("Set-Cookie", cookies);
+    safeSetHeader("Set-Cookie", cookies);
 
     return response;
   };
@@ -134,9 +162,11 @@ export function createResponse(res: ServerResponse): Tina4Response {
   };
 
   response.file = function (filePath: string, options?: { download?: boolean; contentType?: string }): Tina4Response {
+    if (res.headersSent) return response;
+
     if (!fs.existsSync(filePath)) {
       res.statusCode = 404;
-      res.end("File not found");
+      safeEnd("File not found");
       return response;
     }
 
@@ -152,28 +182,56 @@ export function createResponse(res: ServerResponse): Tina4Response {
       ".txt": "text/plain", ".mp4": "video/mp4", ".mp3": "audio/mpeg",
     };
 
-    res.setHeader("Content-Type", options?.contentType || mimeTypes[ext] || "application/octet-stream");
-    res.setHeader("Content-Length", content.length);
+    safeSetHeader("Content-Type", options?.contentType || mimeTypes[ext] || "application/octet-stream");
+    safeSetHeader("Content-Length", content.length);
     if (options?.download) {
-      res.setHeader("Content-Disposition", `attachment; filename="${nodePath.basename(filePath)}"`);
+      safeSetHeader("Content-Disposition", `attachment; filename="${nodePath.basename(filePath)}"`);
     }
-    res.end(content);
+    safeEnd(content);
     return response;
   };
 
-  // Default render/template stubs — overwritten by server.ts when Frond is available
-  response.render = async function (templateName: string, _data?: Record<string, unknown>): Promise<Tina4Response> {
-    res.statusCode = 500;
-    response.json({
-      error: "Template engine not available",
-      statusCode: 500,
-      message: "Frond template engine is not initialized. Ensure @tina4/frond is installed.",
-    });
-    return response;
+  // ── Template rendering via Frond ──
+
+  response.render = async function (
+    templateName: string,
+    data?: Record<string, unknown>,
+    status?: number,
+    templateDir?: string,
+  ): Promise<Tina4Response> {
+    try {
+      const { Frond } = await import("@tina4/frond");
+      const dir = templateDir ?? _defaultTemplatesDir ?? nodePath.resolve(process.cwd(), "src/templates");
+      let engine = _frondCache.get(dir);
+      if (!engine) {
+        engine = new Frond(dir);
+        _frondCache.set(dir, engine);
+      }
+      const html = engine.render(templateName, data ?? {});
+      if (res.headersSent) return response;
+      if (status !== undefined) res.statusCode = status;
+      else res.statusCode = 200;
+      safeSetHeader("Content-Type", "text/html; charset=utf-8");
+      safeEnd(html);
+      return response;
+    } catch (err) {
+      res.statusCode = 500;
+      response.json({
+        error: "Template engine error",
+        statusCode: 500,
+        message: err instanceof Error ? err.message : "Frond template engine is not available. Ensure @tina4/frond is installed.",
+      });
+      return response;
+    }
   };
 
-  response.template = async function (name: string, data?: Record<string, unknown>): Promise<Tina4Response> {
-    return response.render(name, data);
+  response.template = async function (
+    name: string,
+    data?: Record<string, unknown>,
+    status?: number,
+    templateDir?: string,
+  ): Promise<Tina4Response> {
+    return response.render(name, data, status, templateDir);
   };
 
   return response;

package/packages/core/src/router.ts

@@ -247,6 +247,11 @@ export class Router {
     return all;
   }
 
+  /** Alias for getRoutes(). */
+  allRoutes(): RouteDefinition[] {
+    return this.getRoutes();
+  }
+
   /**
    * List all routes in a debug-friendly format for CLI output.
    */

package/packages/core/src/server.ts

@@ -11,7 +11,7 @@ import { Router, defaultRouter, runRouteMiddlewares } from "./router.js";
 import { validToken } from "./auth.js";
 import { discoverRoutes } from "./routeDiscovery.js";
 import { createRequest, parseBody } from "./request.js";
-import { createResponse } from "./response.js";
+import { createResponse, setDefaultTemplatesDir } from "./response.js";
 import { MiddlewareChain, cors, requestLogger } from "./middleware.js";
 import { tryServeStatic } from "./static.js";
 import { loadEnv, isTruthy } from "./dotenv.js";
@@ -461,6 +461,7 @@ ${reset}
 
   // Initialize Frond template engine
   let frondEngine: any = null;
+  setDefaultTemplatesDir(templatesDir);
   try {
     const { Frond } = await import("@tina4/frond");
     frondEngine = new Frond(templatesDir);
@@ -610,13 +611,7 @@ ${reset}
       } as typeof rawRes.end;
     }
 
-    // Add res.render() if Frond is available
-    if (frondEngine) {
-      res.render = (template: string, data?: Record<string, unknown>, statusCode?: number) => {
-        const html = frondEngine.render(template, data);
-        return res.html(html, statusCode ?? 200);
-      };
-    }
+    // res.render() / res.template() are handled natively by response.ts via Frond
 
     try {
       // Run middleware chain

package/packages/core/src/types.ts

@@ -49,8 +49,8 @@ export interface Tina4ResponseMethods {
   clearCookie(name: string, options?: CookieOptions): Tina4Response;
   file(path: string, options?: { download?: boolean; contentType?: string }): Tina4Response;
   error(code: string, message: string, status?: number): Tina4Response;
-  render(template: string, data?: Record<string, unknown>): Promise<Tina4Response>;
-  template(name: string, data?: Record<string, unknown>): Promise<Tina4Response>;
+  render(template: string, data?: Record<string, unknown>, status?: number, templateDir?: string): Promise<Tina4Response>;
+  template(name: string, data?: Record<string, unknown>, status?: number, templateDir?: string): Promise<Tina4Response>;
   /** The underlying ServerResponse for advanced use */
   raw: ServerResponse;
 }

package/packages/orm/src/baseModel.ts

@@ -188,6 +188,31 @@ export class BaseModel {
     return instance;
   }
 
+  /**
+   * Create a new instance from data, save it, and return the saved instance.
+   *
+   * Usage:
+   *   const user = User.create({ name: "Alice", email: "alice@example.com" });
+   */
+  static create<T extends BaseModel>(
+    this: new (data?: Record<string, unknown>) => T,
+    data: Record<string, unknown>,
+  ): T {
+    const instance = new this(data) as T;
+    instance.save();
+    return instance;
+  }
+
+  /** Alias for findById(). */
+  static find<T extends BaseModel>(this: new (data?: Record<string, unknown>) => T, id: unknown, include?: string[]): T | null {
+    return (this as unknown as typeof BaseModel).findById.call(this, id, include) as T | null;
+  }
+
+  /** Alias for findById(). */
+  static load<T extends BaseModel>(this: new (data?: Record<string, unknown>) => T, id: unknown, include?: string[]): T | null {
+    return (this as unknown as typeof BaseModel).findById.call(this, id, include) as T | null;
+  }
+
   /**
    * Find all records, optionally with a where clause.
    * @param where Optional WHERE clause.

package/packages/orm/src/database.ts

@@ -393,6 +393,44 @@ export class Database {
     return this.getNextAdapter().tables();
   }
 
+  /**
+   * Get column metadata for a table.
+   * Uses the adapter's columns() method which handles engine-specific introspection
+   * (PRAGMA table_info for SQLite, information_schema.columns for others).
+   *
+   * @param tableName - Name of the table to inspect.
+   * @returns Array of column info objects: { name, type, nullable, default, primaryKey }.
+   */
+  getColumns(tableName: string): { name: string; type: string; nullable?: boolean; default?: unknown; primaryKey?: boolean }[] {
+    return this.getNextAdapter().columns(tableName);
+  }
+
+  /**
+   * Execute a SQL statement with multiple parameter sets (batch insert/update).
+   * Wraps all executions in a single transaction for atomicity and performance.
+   *
+   * @param sql - The SQL statement with parameter placeholders.
+   * @param paramSets - Array of parameter arrays, one per execution.
+   * @returns Array of results from each execution.
+   */
+  executeMany(sql: string, paramSets: unknown[][]): unknown[] {
+    const adapter = this.getNextAdapter();
+    const results: unknown[] = [];
+
+    adapter.startTransaction();
+    try {
+      for (const params of paramSets) {
+        results.push(adapter.execute(sql, params));
+      }
+      adapter.commit();
+    } catch (e) {
+      adapter.rollback();
+      throw e;
+    }
+
+    return results;
+  }
+
   /** Get the last auto-increment id. */
   getLastId(): string | number {
     const id = this.getNextAdapter().lastInsertId();