tina4-nodejs 3.5.0 → 3.7.1

package/README.md

@@ -371,7 +371,7 @@ export default class User {
     };
 }
 
-// Auto-generates: GET/POST /api/users, GET/PUT/DELETE /api/users/:id
+// Auto-generates: GET/POST /api/users, GET/PUT/DELETE /api/users/{id}
 // With filtering, sorting, pagination, and validation built in
 ```
 
@@ -409,10 +409,10 @@ get("/protected", async (request, response) => {
 ### JWT Authentication
 
 ```typescript
-import { createToken, validateToken } from "tina4-nodejs";
+import { getToken, validToken } from "tina4-nodejs";
 
-const token = createToken({userId: 42}, "your-secret");
-const payload = validateToken(token, "your-secret");
+const token = getToken({userId: 42}, "your-secret");
+const payload = validToken(token, "your-secret");
 ```
 
 POST/PUT/PATCH/DELETE routes require `Authorization: Bearer <token>` by default. Use `noauth()` to make public, `secured()` to protect GET routes.
@@ -643,7 +643,7 @@ DATABASE_USERNAME=admin              # Separate credentials for networked databa
 DATABASE_PASSWORD=secret
 TINA4_DEBUG=true                     # Enable dev toolbar, error overlay
 TINA4_LOG_LEVEL=ALL                  # ALL, DEBUG, INFO, WARNING, ERROR
-TINA4_LANGUAGE=en                    # en, fr, af, zh, ja, es
+TINA4_LOCALE=en                      # en, fr, af, zh, ja, es
 TINA4_SESSION_HANDLER=SessionFileHandler
 SWAGGER_TITLE=My API
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tina4-nodejs",
-  "version": "3.5.0",
+  "version": "3.7.1",
   "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/cli/src/commands/serve.ts

@@ -10,11 +10,12 @@ export async function serveProject(options: ServeOptions): Promise<void> {
   const cwd = process.cwd();
 
   const routesDir = resolve(cwd, "src/routes");
+  const ormDir = resolve(cwd, "src/orm");
   const modelsDir = resolve(cwd, "src/models");
   const templatesDir = resolve(cwd, "src/templates");
   const staticDir = resolve(cwd, "public");
 
-  if (!existsSync(routesDir) && !existsSync(modelsDir)) {
+  if (!existsSync(routesDir) && !existsSync(modelsDir) && !existsSync(ormDir)) {
     console.error("  Error: Not a Tina4 project. Run this from a project created with 'tina4 init'.");
     process.exit(1);
   }
@@ -31,7 +32,8 @@ export async function serveProject(options: ServeOptions): Promise<void> {
   });
 
   // Watch for file changes and reload routes
-  const watcher = watchForChanges([routesDir, modelsDir, templatesDir], async () => {
+  const watchDirs = [routesDir, ormDir, modelsDir, templatesDir].filter((d) => existsSync(d));
+  const watcher = watchForChanges(watchDirs, async () => {
     try {
       const { discoverRoutes } = await import("@tina4/core");
       const routes = await discoverRoutes(routesDir);

package/packages/core/src/server.ts

@@ -1,6 +1,6 @@
 import { createServer } from "node:http";
 import { resolve, dirname, join, relative } from "node:path";
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { isatty } from "node:tty";
 import { fileURLToPath } from "node:url";
 import cluster from "node:cluster";
@@ -166,6 +166,51 @@ function getGalleryDeployedState(): Record<string, boolean> {
   return state;
 }
 
+/** Template cache: url_path -> template_file. Null until first production lookup. */
+let templateCache: Map<string, string> | null = null;
+
+/**
+ * Resolve a URL path to a template file in src/templates/.
+ * Dev mode: checks filesystem every time for live changes.
+ * Production: uses a cached lookup built once at startup.
+ */
+function resolveTemplate(pathname: string, templatesDir: string): string | null {
+  const cleanPath = pathname.replace(/^\//, "") || "index";
+  const isDev = (process.env.TINA4_DEBUG ?? "false").toLowerCase() === "true";
+
+  if (isDev) {
+    for (const ext of [".twig", ".html"]) {
+      const candidate = cleanPath + ext;
+      if (existsSync(resolve(templatesDir, candidate))) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+
+  // Production: cached lookup
+  if (!templateCache) {
+    templateCache = new Map();
+    if (existsSync(templatesDir)) {
+      const scan = (dir: string, prefix: string) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+          const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+          if (entry.isDirectory()) {
+            scan(resolve(dir, entry.name), rel);
+          } else if (entry.name.endsWith(".twig") || entry.name.endsWith(".html")) {
+            const urlPath = rel.replace(/\.(twig|html)$/, "");
+            if (!templateCache!.has(urlPath)) {
+              templateCache!.set(urlPath, rel);
+            }
+          }
+        }
+      };
+      scan(templatesDir, "");
+    }
+  }
+  return templateCache.get(cleanPath) ?? null;
+}
+
 function renderLandingPage(routes: Array<{ method: string; pattern: string; flags?: string[] }>, port: number = 7148): string {
   const version = TINA4_VERSION;
 
@@ -383,6 +428,7 @@ ${reset}
   const base = config?.basePath ? resolve(config.basePath) : process.cwd();
   const routesDir = resolve(base, config?.routesDir ?? "src/routes");
   const modelsDir = resolve(base, config?.modelsDir ?? "src/models");
+  const ormDir = resolve(base, "src/orm");
   const staticDir = resolve(base, config?.staticDir ?? "public");
   const templatesDir = resolve(base, config?.templatesDir ?? "src/templates");
 
@@ -429,8 +475,10 @@ ${reset}
     console.log(`\n  No routes directory found at ${routesDir}`);
   }
 
-  // Initialize ORM if models directory exists
-  if (existsSync(modelsDir)) {
+  // Initialize ORM if models directory exists (check src/orm/ first, then src/models/)
+  const hasOrmDir = existsSync(ormDir);
+  const hasModelsDir = existsSync(modelsDir);
+  if (hasOrmDir || hasModelsDir) {
     try {
       const orm = await import("@tina4/orm");
       const dbConfig = config?.database ?? {};
@@ -439,7 +487,18 @@ ${reset}
         path: dbConfig.path ?? "./data/tina4.db",
       });
 
-      const models = await orm.discoverModels(modelsDir);
+      // Discover from src/orm/ (primary) and src/models/ (fallback), merge results
+      let models = hasOrmDir ? await orm.discoverModels(ormDir) : [];
+      if (hasModelsDir) {
+        const extraModels = await orm.discoverModels(modelsDir);
+        // Only add models not already discovered (src/orm/ takes priority)
+        const existingTables = new Set(models.map((m: any) => m.definition.tableName));
+        for (const m of extraModels) {
+          if (!existingTables.has(m.definition.tableName)) {
+            models.push(m);
+          }
+        }
+      }
       if (models.length > 0) {
         console.log(`\n  Models discovered:`);
         orm.syncModels(models);
@@ -476,9 +535,16 @@ ${reset}
     let modelDefs: Array<{ tableName: string; fields: Record<string, unknown> }> = [];
     try {
       const orm = await import("@tina4/orm");
-      if (existsSync(modelsDir)) {
-        const models = await orm.discoverModels(modelsDir);
-        modelDefs = models.map((m) => m.definition);
+      const allModelDirs = [ormDir, modelsDir].filter((d) => existsSync(d));
+      const seenTables = new Set<string>();
+      for (const dir of allModelDirs) {
+        const discovered = await orm.discoverModels(dir);
+        for (const m of discovered) {
+          if (!seenTables.has(m.definition.tableName)) {
+            modelDefs.push(m.definition);
+            seenTables.add(m.definition.tableName);
+          }
+        }
       }
     } catch {
       // ORM not available, swagger will work without model schemas
@@ -631,11 +697,18 @@ ${reset}
         return;
       }
 
-      // Show landing page on "/" if no route matched and no index template exists
-      if (pathname === "/" && (req.method ?? "GET") === "GET") {
-        const hasIndexHtml = existsSync(resolve(templatesDir, "index.html"));
-        const hasIndexTwig = existsSync(resolve(templatesDir, "index.twig"));
-        if (!hasIndexHtml && !hasIndexTwig) {
+      // Try serving a template file (e.g. /hello -> src/templates/hello.twig or hello.html)
+      if ((req.method ?? "GET") === "GET") {
+        const tplFile = resolveTemplate(pathname, templatesDir);
+        if (tplFile) {
+          const html = readFileSync(resolve(templatesDir, tplFile), "utf-8");
+          res.raw.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+          res.raw.end(html);
+          return;
+        }
+
+        // Show landing page for "/" when no template exists
+        if (pathname === "/") {
           const allRoutes = router.getRoutes().map((r) => ({
             method: r.method,
             pattern: r.pattern,

package/packages/orm/src/migration.ts

@@ -5,6 +5,72 @@ import type { SQLiteAdapter } from "./adapters/sqlite.js";
 import type { DiscoveredModel } from "./model.js";
 import { getAdapter } from "./database.js";
 
+// ---------------------------------------------------------------------------
+// Firebird ALTER TABLE ADD idempotency check
+// ---------------------------------------------------------------------------
+// Firebird does not support IF NOT EXISTS for ALTER TABLE ADD. When a migration
+// adds a column that already exists, Firebird throws an error and blocks the
+// entire migration. These helpers detect ALTER TABLE ... ADD statements and
+// query RDB$RELATION_FIELDS to see if the column is already present. If so,
+// the statement is silently skipped rather than executed.
+
+/**
+ * Regex to match ALTER TABLE <table> ADD <column> ...
+ * Captures table name and column name (quoted or unquoted).
+ */
+const ALTER_ADD_RE =
+  /^\s*ALTER\s+TABLE\s+(?:"([^"]+)"|(\S+))\s+ADD\s+(?:"([^"]+)"|(\S+))/i;
+
+/**
+ * Check if the adapter is a Firebird adapter (duck-type check).
+ * We look for the `queryAsync` method and `translateSql` which are
+ * unique to the Firebird adapter.
+ */
+function isFirebirdAdapter(db: DatabaseAdapter): boolean {
+  return (
+    typeof (db as any).queryAsync === "function" &&
+    typeof (db as any).translateSql === "function"
+  );
+}
+
+/**
+ * Check if a column already exists in a Firebird table.
+ */
+async function firebirdColumnExists(
+  db: DatabaseAdapter,
+  table: string,
+  column: string,
+): Promise<boolean> {
+  const rows = await (db as any).queryAsync<Record<string, unknown>>(
+    "SELECT 1 FROM RDB$RELATION_FIELDS WHERE RDB$RELATION_NAME = ? AND TRIM(RDB$FIELD_NAME) = ?",
+    [table.toUpperCase(), column.toUpperCase()],
+  );
+  return rows.length > 0;
+}
+
+/**
+ * If stmt is an ALTER TABLE ... ADD on Firebird and the column already exists,
+ * returns a skip reason string. Returns null if the statement should execute normally.
+ */
+async function shouldSkipForFirebird(
+  db: DatabaseAdapter,
+  stmt: string,
+): Promise<string | null> {
+  if (!isFirebirdAdapter(db)) return null;
+
+  const m = stmt.match(ALTER_ADD_RE);
+  if (!m) return null;
+
+  const table = m[1] ?? m[2];
+  const column = m[3] ?? m[4];
+
+  if (await firebirdColumnExists(db, table, column)) {
+    return `Column ${column} already exists in ${table}, skipping`;
+  }
+
+  return null;
+}
+
 /**
  * Sync model definitions to the database (create tables, add columns).
  */
@@ -458,6 +524,14 @@ export async function migrate(
       db.startTransaction();
 
       for (const stmt of statements) {
+        // Firebird lacks IF NOT EXISTS for ALTER TABLE ADD.
+        // Pre-check the system catalogue so duplicate columns are
+        // silently skipped instead of raising an error.
+        const skipReason = await shouldSkipForFirebird(db, stmt);
+        if (skipReason) {
+          console.log(`  Migration ${file}: ${skipReason}`);
+          continue;
+        }
         db.execute(stmt);
       }