tina4-nodejs 3.6.0 → 3.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tina4-nodejs",
-  "version": "3.6.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/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/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);
       }