tina4-nodejs 3.10.48 → 3.10.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tina4-nodejs",
-  "version": "3.10.48",
+  "version": "3.10.50",
   "type": "module",
   "description": "Tina4 for Node.js/TypeScript — 54 built-in features, zero dependencies",
   "keywords": ["tina4", "framework", "web", "api", "orm", "graphql", "websocket", "typescript"],

package/packages/cli/src/commands/init.ts

@@ -1,5 +1,6 @@
-import { mkdirSync, writeFileSync, existsSync } from "node:fs";
-import { join, resolve, basename } from "node:path";
+import { mkdirSync, writeFileSync, existsSync, copyFileSync } from "node:fs";
+import { join, resolve, basename, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import { execSync } from "node:child_process";
 
 export async function initProject(name: string): Promise<void> {
@@ -30,6 +31,28 @@ export async function initProject(name: string): Promise<void> {
     mkdirSync(join(targetDir, dir), { recursive: true });
   }
 
+  // Copy framework public assets into the project so they're visible
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  const frameworkPublic = resolve(__dirname, "..", "..", "..", "core", "public");
+  const projectPublic = join(targetDir, "public");
+  const assetsToCopy = [
+    "css/tina4.css",
+    "css/tina4.min.css",
+    "js/tina4.min.js",
+    "js/frond.min.js",
+    "images/tina4-logo-icon.webp",
+  ];
+  for (const asset of assetsToCopy) {
+    const src = join(frameworkPublic, ...asset.split("/"));
+    const dst = join(projectPublic, ...asset.split("/"));
+    mkdirSync(dirname(dst), { recursive: true });
+    if (existsSync(src) && !existsSync(dst)) {
+      copyFileSync(src, dst);
+      console.log(`  Copied ${asset}`);
+    }
+  }
+
   // package.json
   writeFileSync(
     join(targetDir, "package.json"),

package/packages/cli/src/commands/serve.ts

@@ -21,8 +21,8 @@ export async function serveProject(options: ServeOptions): Promise<void> {
     process.exit(1);
   }
 
-  const { startServer } = await import("@tina4/core");
-  const { watchForChanges } = await import("@tina4/core/src/watcher.js");
+  const { startServer } = await import("../../../core/src/index.js");
+  const { watchForChanges } = await import("../../../core/src/watcher.js");
 
   const server = await startServer({
     port,
@@ -36,7 +36,7 @@ export async function serveProject(options: ServeOptions): Promise<void> {
   const watchDirs = [routesDir, ormDir, modelsDir, templatesDir].filter((d) => existsSync(d));
   const watcher = watchForChanges(watchDirs, async () => {
     try {
-      const { discoverRoutes } = await import("@tina4/core");
+      const { discoverRoutes } = await import("../../../core/src/index.js");
       // Clear routes BEFORE re-discovery to avoid stale duplicates
       server.router.clear();
       const routes = await discoverRoutes(routesDir);

package/packages/core/src/request.ts

@@ -106,7 +106,7 @@ function extractBoundary(contentType: string): string | null {
  * Parse multipart/form-data body into fields and files.
  * Zero-dependency implementation.
  */
-function parseMultipart(
+export function parseMultipart(
   body: Buffer,
   boundary: string,
 ): { fields: Record<string, string>; files: UploadedFile[] } {

package/packages/core/src/router.ts

@@ -413,6 +413,11 @@ export class Router {
           paramNames.push(name);
           return "([^/]+)";
         }
+        // Wildcard: * (catch-all, param key is "*")
+        if (segment === "*") {
+          paramNames.push("*");
+          return "(.+)";
+        }
         return segment;
       })
       .join("/");

package/packages/core/src/server.ts

@@ -29,7 +29,18 @@ const BUILTIN_ERROR_TEMPLATES_DIR = resolve(__dirname, "..", "templates");
 /** Built-in public directory for framework-bundled static assets. */
 const BUILTIN_PUBLIC_DIR = resolve(__dirname, "..", "public");
 
-const TINA4_VERSION = "3.10.30";
+/** Read version from root package.json so the banner always matches the published version. */
+function readPackageVersion(): string {
+  try {
+    const pkgPath = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+const TINA4_VERSION = readPackageVersion();
 
 /** Cache Frond instances by template directory to avoid repeated instantiation. */
 const frondCache = new Map<string, InstanceType<any>>();
@@ -94,7 +105,7 @@ async function renderErrorPage(
   templatesDir: string,
 ): Promise<string | null> {
   try {
-    const { Frond } = await import("@tina4/frond");
+    const { Frond } = await import("../../frond/src/engine.js");
     const templateFile = `errors/${code}.twig`;
 
     // Helper: get-or-create a cached Frond instance for a directory
@@ -494,7 +505,7 @@ ${reset}
   let frondEngine: any = null;
   setDefaultTemplatesDir(templatesDir);
   try {
-    const { Frond } = await import("@tina4/frond");
+    const { Frond } = await import("../../frond/src/engine.js");
     frondEngine = new Frond(templatesDir);
   } catch {
     // Frond not available
@@ -524,7 +535,7 @@ ${reset}
   const hasModelsDir = existsSync(modelsDir);
   if (hasOrmDir || hasModelsDir) {
     try {
-      const orm = await import("@tina4/orm");
+      const orm = await import("../../orm/src/index.js");
       const dbConfig = config?.database ?? {};
       await orm.initDatabase({
         type: dbConfig.type ?? "sqlite",
@@ -572,13 +583,13 @@ ${reset}
 
   // Initialize Swagger
   try {
-    const swagger = await import("@tina4/swagger");
+    const swagger = await import("../../swagger/src/index.js");
     const allRoutes = router.getRoutes();
 
     // Collect model definitions for schema generation
     let modelDefs: Array<{ tableName: string; fields: Record<string, unknown> }> = [];
     try {
-      const orm = await import("@tina4/orm");
+      const orm = await import("../../orm/src/index.js");
       const allModelDirs = [ormDir, modelsDir].filter((d) => existsSync(d));
       const seenTables = new Set<string>();
       for (const dir of allModelDirs) {
@@ -730,7 +741,9 @@ ${reset}
         }
 
         // Auth enforcement: secure routes require a valid Bearer token
-        if (match.secure === true && match.noAuth !== true) {
+        // Dev admin routes (/__dev) are always public
+        const isDevAdmin = pathname.startsWith("/__dev");
+        if (match.secure === true && match.noAuth !== true && !isDevAdmin) {
           const authHeader = req.headers.authorization ?? "";
           const token = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : "";
           const secret = process.env.SECRET || "";
@@ -875,12 +888,15 @@ ${reset}
   Dashboard: http://localhost:${port}/__dev
   Debug:     ${isDebug ? "ON" : "OFF"} (Log level: ${logLevel})
 `);
-      openBrowser(`http://${displayHost}:${port}`);
+      const noBrowser = isTruthy(process.env.TINA4_NO_BROWSER);
+      if (!noBrowser) {
+        openBrowser(`http://${displayHost}:${port}`);
+      }
       resolvePromise({
         close: () => {
           server.close();
           // Close database if ORM was initialized
-          import("@tina4/orm").then((orm) => orm.closeDatabase()).catch(() => {});
+          import("../../orm/src/index.js").then((orm) => orm.closeDatabase()).catch(() => {});
         },
         router,
         port,

package/packages/core/src/session.ts

@@ -100,15 +100,23 @@ export class FileSessionHandler implements SessionHandler {
     try {
       if (!existsSync(filePath)) return null;
       const raw = readFileSync(filePath, "utf-8");
-      return JSON.parse(raw) as SessionData;
+      const wrapper = JSON.parse(raw);
+      // Check expiry
+      if (wrapper._expires && wrapper._expires > 0 && Date.now() / 1000 > wrapper._expires) {
+        try { unlinkSync(filePath); } catch { /* ignore */ }
+        return null;
+      }
+      return (wrapper._data ?? wrapper) as SessionData;
     } catch {
       return null;
     }
   }
 
-  write(sessionId: string, data: SessionData, _ttl: number): void {
+  write(sessionId: string, data: SessionData, ttl: number): void {
     this.ensureDir();
-    writeFileSync(this.filePath(sessionId), JSON.stringify(data), "utf-8");
+    const expires = ttl > 0 ? Math.floor(Date.now() / 1000) + ttl : 0;
+    const wrapper = { _data: data, _expires: expires };
+    writeFileSync(this.filePath(sessionId), JSON.stringify(wrapper), "utf-8");
   }
 
   destroy(sessionId: string): void {
@@ -118,7 +126,7 @@ export class FileSessionHandler implements SessionHandler {
     } catch { /* ignore */ }
   }
 
-  gc(maxLifetime: number): void {
+  gc(_maxLifetime: number): void {
     if (!existsSync(this.storagePath)) return;
     const now = Math.floor(Date.now() / 1000);
     try {
@@ -128,8 +136,8 @@ export class FileSessionHandler implements SessionHandler {
         const fullPath = join(this.storagePath, file);
         try {
           const raw = readFileSync(fullPath, "utf-8");
-          const data = JSON.parse(raw) as SessionData;
-          if (data._accessed && (now - data._accessed) > maxLifetime) {
+          const wrapper = JSON.parse(raw);
+          if (wrapper._expires && wrapper._expires > 0 && now > wrapper._expires) {
             unlinkSync(fullPath);
           }
         } catch {

package/packages/orm/src/autoCrud.ts

@@ -45,7 +45,7 @@ export function generateCrudRoutes(models: DiscoveredModel[]): RouteDefinition[]
         const items = adapter.query(sql, params);
         const [{ total }] = adapter.query<{ total: number }>(countSql, countParams);
 
-        const limit = options.limit ?? 20;
+        const limit = options.limit ?? 100;
         const page = options.page ?? 1;
 
         res.json({

package/packages/orm/src/databaseResult.ts

@@ -73,18 +73,27 @@ export class DatabaseResult implements Iterable<Record<string, unknown>> {
     return this.records;
   }
 
-  /** Pagination envelope. */
-  toPaginate(): {
-    records: Record<string, unknown>[];
-    count: number;
-    limit: number;
-    offset: number;
+  /** Pagination envelope with slicing. */
+  toPaginate(page = 1, perPage = 10): {
+    data: Record<string, unknown>[];
+    page: number;
+    per_page: number;
+    total: number;
+    total_pages: number;
+    has_next: boolean;
+    has_prev: boolean;
   } {
+    const totalPages = Math.max(1, Math.ceil(this.count / perPage));
+    const start = (page - 1) * perPage;
+    const end = start + perPage;
     return {
-      records: this.records,
-      count: this.count,
-      limit: this.limit,
-      offset: this.offset,
+      data: this.records.slice(start, end),
+      page,
+      per_page: perPage,
+      total: this.count,
+      total_pages: totalPages,
+      has_next: page < totalPages,
+      has_prev: page > 1,
     };
   }
 

package/packages/orm/src/query.ts

@@ -58,7 +58,7 @@ export function buildQuery(
   }
 
   // Pagination
-  const limit = options.limit ?? 20;
+  const limit = options.limit ?? 100;
   const page = options.page ?? 1;
   const offset = (page - 1) * limit;