tina4-nodejs 3.6.0 → 3.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tina4-nodejs",
-  "version": "3.6.0",
+  "version": "3.8.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/router.ts

@@ -359,11 +359,26 @@ export class Router {
           paramNames.push(name);
           return "(.+)";
         }
-        // Dynamic param: {id} (primary syntax, matching Python)
+        // Dynamic param: {id}, {id:int}, {id:float}, {id:path} (matching Python/Ruby)
         if (segment.startsWith("{") && segment.endsWith("}")) {
-          const name = segment.slice(1, -1);
+          const inner = segment.slice(1, -1);
+          const colonIdx = inner.indexOf(":");
+          const name = colonIdx >= 0 ? inner.slice(0, colonIdx) : inner;
+          const type = colonIdx >= 0 ? inner.slice(colonIdx + 1) : "string";
           paramNames.push(name);
-          return "([^/]+)";
+          switch (type) {
+            case "int":
+            case "integer":
+              return "(\\d+)";
+            case "float":
+            case "number":
+              return "([\\d.]+)";
+            case "path":
+            case ".*":
+              return "(.+)";
+            default:
+              return "([^/]+)";
+          }
         }
         // Dynamic param: [id] (file-based routing internal syntax)
         if (segment.startsWith("[") && segment.endsWith("]")) {

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;
 
@@ -652,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/frond/src/engine.ts

@@ -758,7 +758,9 @@ const BUILTIN_FILTERS: Record<string, FilterFn> = {
   md5: (v) => createHash("md5").update(String(v)).digest("hex"),
   sha256: (v) => createHash("sha256").update(String(v)).digest("hex"),
   base64_encode: (v) => Buffer.isBuffer(v) ? v.toString("base64") : Buffer.from(String(v)).toString("base64"),
+  base64encode: (v) => Buffer.isBuffer(v) ? v.toString("base64") : Buffer.from(String(v)).toString("base64"),
   base64_decode: (v) => Buffer.from(String(v), "base64").toString("utf-8"),
+  base64decode: (v) => Buffer.from(String(v), "base64").toString("utf-8"),
   data_uri: (v) => {
     if (v && typeof v === "object" && "content" in v) {
       const ct = (v as any).type ?? "application/octet-stream";

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);
       }