tina4-nodejs 3.0.0-rc.2

package/packages/cli/src/bin.ts

@@ -0,0 +1,110 @@
+import { initProject } from "./commands/init.js";
+import { serveProject } from "./commands/serve.js";
+import { runMigrations } from "./commands/migrate.js";
+import { createMigration } from "./commands/migrateCreate.js";
+import { listRoutes } from "./commands/routes.js";
+import { runTests } from "./commands/test.js";
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+const HELP = `
+  tina4nodejs — This is not a framework.
+
+  Usage:
+    tina4nodejs init [dir]            Create a new Tina4 project (default: current directory)
+    tina4nodejs serve                 Start the dev server with hot-reload
+    tina4nodejs migrate               Run pending SQL migrations
+    tina4nodejs migrate:create <desc> Create a new migration file
+    tina4nodejs routes                List all registered routes
+    tina4nodejs test [file]           Run project tests
+    tina4nodejs ai                    Detect AI coding tools and install context
+    tina4nodejs help                  Show this help message
+
+  Options:
+    --port <number>      Server port (default: 7148)
+    --all                Install AI context for all tools (with ai command)
+    --force              Overwrite existing AI context files (with ai command)
+    --help               Show this help message
+`;
+
+async function main(): Promise<void> {
+  switch (command) {
+    case "init": {
+      const name = args[1] || ".";
+      await initProject(name);
+      break;
+    }
+    case "serve": {
+      const portIndex = args.indexOf("--port");
+      const port = portIndex !== -1 ? parseInt(args[portIndex + 1], 10) : 7148;
+      await serveProject({ port });
+      break;
+    }
+    case "migrate": {
+      await runMigrations(args[1]);
+      break;
+    }
+    case "migrate:create": {
+      const description = args.slice(1).join(" ");
+      await createMigration(description || undefined);
+      break;
+    }
+    case "routes": {
+      await listRoutes();
+      break;
+    }
+    case "test": {
+      await runTests(args[1]);
+      break;
+    }
+    case "ai": {
+      const { detectAi, installAiContext, installAllAiContext, aiStatusReport } = await import("../../core/src/ai.js");
+      const root = args[1] || ".";
+      const installAll = args.includes("--all");
+      const force = args.includes("--force");
+
+      // Show status
+      console.log(aiStatusReport(root));
+
+      // Install context
+      if (installAll) {
+        const created = installAllAiContext(root, force);
+        if (created.length > 0) {
+          console.log("Installed AI context files:");
+          for (const f of created) {
+            console.log(`  + ${f}`);
+          }
+        } else {
+          console.log("All AI context files already exist (use --force to overwrite).");
+        }
+      } else {
+        const created = installAiContext(root, { force });
+        if (created.length > 0) {
+          console.log("Installed AI context files:");
+          for (const f of created) {
+            console.log(`  + ${f}`);
+          }
+        } else {
+          console.log("No new AI context files needed.");
+        }
+      }
+      break;
+    }
+    case "help":
+    case "--help":
+    case "-h":
+    case undefined:
+      console.log(HELP);
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.log(HELP);
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

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

@@ -0,0 +1,194 @@
+import { mkdirSync, writeFileSync, existsSync } from "node:fs";
+import { join, resolve, basename } from "node:path";
+import { execSync } from "node:child_process";
+
+export async function initProject(name: string): Promise<void> {
+  const targetDir = name === "." ? process.cwd() : resolve(name);
+  const projectName = name === "." ? basename(process.cwd()) : basename(name);
+
+  if (name !== "." && existsSync(targetDir)) {
+    console.error(`Error: Directory "${targetDir}" already exists.`);
+    process.exit(1);
+  }
+
+  console.log(`\n  Creating Tina4 project: ${projectName}\n`);
+
+  // Create directory structure
+  const dirs = [
+    "",
+    "src",
+    "src/routes",
+    "src/routes/api",
+    "src/routes/api/hello",
+    "src/models",
+    "src/templates",
+    "public",
+    "data",
+  ];
+
+  for (const dir of dirs) {
+    mkdirSync(join(targetDir, dir), { recursive: true });
+  }
+
+  // package.json
+  writeFileSync(
+    join(targetDir, "package.json"),
+    JSON.stringify(
+      {
+        name: projectName,
+        version: "0.0.1",
+        private: true,
+        type: "module",
+        scripts: {
+          dev: "tina4 serve",
+          serve: "tina4 serve",
+        },
+        dependencies: {
+          "tina4-nodejs": "^0.0.1",
+        },
+        devDependencies: {
+          typescript: "^5.7.0",
+          tsx: "^4.19.0",
+        },
+      },
+      null,
+      2
+    ) + "\n"
+  );
+
+  // tsconfig.json
+  writeFileSync(
+    join(targetDir, "tsconfig.json"),
+    JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2022",
+          module: "Node16",
+          moduleResolution: "Node16",
+          strict: true,
+          esModuleInterop: true,
+          skipLibCheck: true,
+          outDir: "./dist",
+          rootDir: "./src",
+        },
+        include: ["src"],
+      },
+      null,
+      2
+    ) + "\n"
+  );
+
+  // .gitignore
+  writeFileSync(
+    join(targetDir, ".gitignore"),
+    `node_modules/
+dist/
+*.db
+*.sqlite
+.env
+.DS_Store
+data/
+`
+  );
+
+  // Sample route: GET /api/hello
+  writeFileSync(
+    join(targetDir, "src/routes/api/hello/get.ts"),
+    `import type { Tina4Request, Tina4Response } from "tina4-nodejs";
+
+export const meta = {
+  summary: "Hello World",
+  tags: ["Example"],
+};
+
+export default async function (req: Tina4Request, res: Tina4Response): Promise<void> {
+  res.json({ message: "Hello from Tina4!", timestamp: new Date().toISOString() });
+}
+`
+  );
+
+  // Sample model: Example
+  writeFileSync(
+    join(targetDir, "src/models/Example.ts"),
+    `export default class Example {
+  static tableName = "examples";
+
+  static fields = {
+    id: { type: "integer" as const, primaryKey: true, autoIncrement: true },
+    name: { type: "string" as const, required: true, maxLength: 255 },
+    description: { type: "text" as const },
+    active: { type: "boolean" as const, default: true },
+    createdAt: { type: "datetime" as const, default: "now" },
+  };
+}
+`
+  );
+
+  // Sample template
+  writeFileSync(
+    join(targetDir, "src/templates/welcome.html.twig"),
+    `<!DOCTYPE html>
+<html>
+<head>
+  <title>{{ title }}</title>
+</head>
+<body>
+  <h1>Welcome to {{ name }}</h1>
+  <p>This is not a framework.</p>
+</body>
+</html>
+`
+  );
+
+  // Static index page
+  writeFileSync(
+    join(targetDir, "public/index.html"),
+    `<!DOCTYPE html>
+<html>
+<head>
+  <title>Tina4</title>
+  <style>
+    body { font-family: -apple-system, sans-serif; max-width: 600px; margin: 80px auto; padding: 0 20px; color: #333; }
+    h1 { font-size: 2.5em; margin-bottom: 0.2em; }
+    p { color: #666; font-size: 1.1em; }
+    code { background: #f4f4f4; padding: 2px 6px; border-radius: 3px; font-size: 0.9em; }
+    a { color: #2563eb; }
+  </style>
+</head>
+<body>
+  <h1>tina4</h1>
+  <p><em>This is not a framework.</em></p>
+  <p>Your API is running. Try:</p>
+  <ul>
+    <li><a href="/api/hello">GET /api/hello</a></li>
+    <li><a href="/swagger">API Documentation</a></li>
+  </ul>
+</body>
+</html>
+`
+  );
+
+  console.log("  Installing dependencies...\n");
+
+  let npmOk = true;
+  try {
+    execSync("npm install", { cwd: targetDir, stdio: "inherit" });
+  } catch {
+    npmOk = false;
+    console.log("\n  Note: npm install failed — the package may not be published yet.");
+    console.log("  Your project files have been created. You can install dependencies later.\n");
+  }
+
+  const absPath = resolve(targetDir);
+  const cdStep = name === "." ? "" : `    cd ${absPath}\n`;
+  console.log(`
+  Done! Your Tina4 project is ready.
+
+  Next steps:
+${cdStep}    npm install
+    npx tina4nodejs serve
+
+  Your API will be running at http://localhost:7148
+  Swagger docs at http://localhost:7148/swagger
+`);
+}

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

@@ -0,0 +1,96 @@
+/**
+ * CLI command: migrate — Run pending SQL migration files.
+ *
+ * Scans the migrations/ directory for .sql files, executes them in order,
+ * and records each as applied via the ORM migration tracker.
+ */
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+export async function runMigrations(migrationDir?: string): Promise<void> {
+  const dir = resolve(migrationDir ?? "migrations");
+
+  if (!existsSync(dir)) {
+    console.log("  No migrations/ directory found. Nothing to run.");
+    return;
+  }
+
+  // Initialise the database so the adapter is available
+  let initDatabase: typeof import("@tina4/orm").initDatabase;
+  let ensureMigrationTable: typeof import("@tina4/orm").ensureMigrationTable;
+  let isMigrationApplied: typeof import("@tina4/orm").isMigrationApplied;
+  let recordMigration: typeof import("@tina4/orm").recordMigration;
+  let getNextBatch: typeof import("@tina4/orm").getNextBatch;
+  let getAdapter: typeof import("@tina4/orm").getAdapter;
+
+  try {
+    const orm = await import("@tina4/orm");
+    initDatabase = orm.initDatabase;
+    ensureMigrationTable = orm.ensureMigrationTable;
+    isMigrationApplied = orm.isMigrationApplied;
+    recordMigration = orm.recordMigration;
+    getNextBatch = orm.getNextBatch;
+    getAdapter = orm.getAdapter;
+  } catch {
+    console.error("  Error: @tina4/orm is required to run migrations.");
+    process.exit(1);
+  }
+
+  // Ensure database is initialised (uses DATABASE_URL or defaults to sqlite)
+  try {
+    initDatabase();
+  } catch {
+    // Adapter may already be set — ignore
+  }
+
+  ensureMigrationTable();
+
+  // Collect .sql files sorted alphabetically
+  const files = readdirSync(dir)
+    .filter((f) => f.endsWith(".sql"))
+    .sort();
+
+  if (files.length === 0) {
+    console.log("  No .sql migration files found.");
+    return;
+  }
+
+  const batch = getNextBatch();
+  let applied = 0;
+
+  for (const file of files) {
+    const name = file.replace(/\.sql$/, "");
+
+    if (isMigrationApplied(name)) {
+      continue;
+    }
+
+    const sql = readFileSync(join(dir, file), "utf-8").trim();
+    if (!sql) continue;
+
+    console.log(`  Migrating: ${file}`);
+
+    const adapter = getAdapter();
+    // Split on semicolons and execute each statement
+    const statements = sql.split(";").map((s) => s.trim()).filter(Boolean);
+
+    for (const stmt of statements) {
+      try {
+        adapter.execute(stmt);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`  Error in ${file}: ${msg}`);
+        process.exit(1);
+      }
+    }
+
+    recordMigration(name, batch);
+    applied++;
+  }
+
+  if (applied === 0) {
+    console.log("  Nothing to migrate — all migrations already applied.");
+  } else {
+    console.log(`  Applied ${applied} migration(s) (batch ${batch}).`);
+  }
+}

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

@@ -0,0 +1,59 @@
+/**
+ * CLI command: migrate:create — Create a new SQL migration file.
+ *
+ * Usage:
+ *   tina4 migrate:create "create users table"
+ *   tina4 migrate:create add_email_to_users
+ *
+ * Creates migrations/000001_description.sql (next sequence number).
+ */
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+export async function createMigration(description?: string): Promise<void> {
+  if (!description) {
+    console.error("  Usage: tina4 migrate:create <description>");
+    console.error('  Example: tina4 migrate:create "create users table"');
+    process.exit(1);
+  }
+
+  const dir = resolve("migrations");
+
+  // Ensure migrations/ exists
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  // Determine the next sequence number
+  const existing = existsSync(dir)
+    ? readdirSync(dir).filter((f) => f.endsWith(".sql")).sort()
+    : [];
+
+  let nextSeq = 1;
+  if (existing.length > 0) {
+    const last = existing[existing.length - 1];
+    const match = last.match(/^(\d+)/);
+    if (match) {
+      nextSeq = parseInt(match[1], 10) + 1;
+    }
+  }
+
+  // Sanitise description for filename
+  const safeName = description
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "_")
+    .replace(/^_|_$/g, "");
+
+  const seqStr = String(nextSeq).padStart(6, "0");
+  const fileName = `${seqStr}_${safeName}.sql`;
+  const filePath = join(dir, fileName);
+
+  const template = `-- Migration: ${description}
+-- Created: ${new Date().toISOString()}
+
+`;
+
+  writeFileSync(filePath, template, "utf-8");
+  console.log(`  Created migration: ${fileName}`);
+  console.log(`  Path: ${filePath}`);
+}

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

@@ -0,0 +1,61 @@
+/**
+ * CLI command: routes — List all registered routes.
+ *
+ * Discovers routes from src/routes/ and displays them in a table.
+ */
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+
+export async function listRoutes(): Promise<void> {
+  const routesDir = resolve("src/routes");
+
+  if (!existsSync(routesDir)) {
+    console.error("  No src/routes/ directory found. Are you in a Tina4 project?");
+    process.exit(1);
+  }
+
+  let discoverRoutes: typeof import("@tina4/core").discoverRoutes;
+
+  try {
+    const core = await import("@tina4/core");
+    discoverRoutes = core.discoverRoutes;
+  } catch {
+    console.error("  Error: @tina4/core is required to list routes.");
+    process.exit(1);
+  }
+
+  const routes = await discoverRoutes(routesDir);
+
+  if (routes.length === 0) {
+    console.log("  No routes found.");
+    return;
+  }
+
+  // Sort by path then method
+  routes.sort((a: { path: string; method: string }, b: { path: string; method: string }) => {
+    const pathCmp = a.path.localeCompare(b.path);
+    return pathCmp !== 0 ? pathCmp : a.method.localeCompare(b.method);
+  });
+
+  console.log("");
+  console.log("  Registered Routes:");
+  console.log("  " + "-".repeat(70));
+  console.log(
+    "  " +
+      "METHOD".padEnd(10) +
+      "PATH".padEnd(40) +
+      "SUMMARY"
+  );
+  console.log("  " + "-".repeat(70));
+
+  for (const route of routes) {
+    const method = route.method.toUpperCase().padEnd(10);
+    const path = route.path.padEnd(40);
+    const summary = route.meta?.summary ?? "";
+    console.log(`  ${method}${path}${summary}`);
+  }
+
+  console.log("  " + "-".repeat(70));
+  console.log(`  Total: ${routes.length} route(s)`);
+  console.log("");
+}

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

@@ -0,0 +1,58 @@
+import { resolve } from "node:path";
+import { existsSync } from "node:fs";
+
+export interface ServeOptions {
+  port?: number;
+}
+
+export async function serveProject(options: ServeOptions): Promise<void> {
+  const port = options.port ?? 7148;
+  const cwd = process.cwd();
+
+  const routesDir = resolve(cwd, "src/routes");
+  const modelsDir = resolve(cwd, "src/models");
+  const templatesDir = resolve(cwd, "src/templates");
+  const staticDir = resolve(cwd, "public");
+
+  if (!existsSync(routesDir) && !existsSync(modelsDir)) {
+    console.error("  Error: Not a Tina4 project. Run this from a project created with 'tina4 init'.");
+    process.exit(1);
+  }
+
+  const { startServer } = await import("@tina4/core");
+  const { watchForChanges } = await import("@tina4/core/src/watcher.js");
+
+  const server = await startServer({
+    port,
+    routesDir,
+    modelsDir,
+    templatesDir,
+    staticDir,
+  });
+
+  // Watch for file changes and reload routes
+  const watcher = watchForChanges([routesDir, modelsDir, templatesDir], async () => {
+    try {
+      const { discoverRoutes } = await import("@tina4/core");
+      const routes = await discoverRoutes(routesDir);
+      server.router.clear();
+      for (const route of routes) {
+        server.router.addRoute(route);
+      }
+      console.log(`  Reloaded ${routes.length} route(s)`);
+    } catch (err) {
+      console.error("  Error reloading routes:", err);
+    }
+  });
+
+  // Graceful shutdown
+  const shutdown = () => {
+    console.log("\n  Shutting down...");
+    watcher.close();
+    server.close();
+    process.exit(0);
+  };
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}

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

@@ -0,0 +1,83 @@
+/**
+ * CLI command: test — Run project tests.
+ *
+ * Looks for test files and executes them with tsx.
+ * Supports: test/integration.ts, test/*.ts, tests/*.ts, *.test.ts patterns.
+ */
+import { existsSync, readdirSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { execSync } from "node:child_process";
+
+export async function runTests(testPath?: string): Promise<void> {
+  const cwd = process.cwd();
+
+  // If a specific test file is provided, run it directly
+  if (testPath) {
+    const file = resolve(testPath);
+    if (!existsSync(file)) {
+      console.error(`  Error: Test file not found: ${testPath}`);
+      process.exit(1);
+    }
+    console.log(`  Running: ${testPath}\n`);
+    try {
+      execSync(`npx tsx "${file}"`, { cwd, stdio: "inherit" });
+    } catch {
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Auto-discover test files
+  const candidates = [
+    "test/integration.ts",
+    "test",
+    "tests",
+  ];
+
+  let testFiles: string[] = [];
+
+  for (const candidate of candidates) {
+    const fullPath = resolve(cwd, candidate);
+    if (!existsSync(fullPath)) continue;
+
+    // If it's a file, run it
+    if (candidate.endsWith(".ts")) {
+      testFiles.push(fullPath);
+      break;
+    }
+
+    // If it's a directory, collect all .ts and .test.ts files
+    try {
+      const files = readdirSync(fullPath)
+        .filter((f) => f.endsWith(".ts"))
+        .map((f) => join(fullPath, f));
+      testFiles.push(...files);
+    } catch {
+      // skip
+    }
+    if (testFiles.length > 0) break;
+  }
+
+  if (testFiles.length === 0) {
+    console.log("  No test files found.");
+    console.log("  Looked in: test/integration.ts, test/*.ts, tests/*.ts");
+    return;
+  }
+
+  console.log(`  Found ${testFiles.length} test file(s)\n`);
+
+  let failed = false;
+  for (const file of testFiles) {
+    const relative = file.replace(cwd + "/", "");
+    console.log(`  Running: ${relative}`);
+    try {
+      execSync(`npx tsx "${file}"`, { cwd, stdio: "inherit" });
+    } catch {
+      failed = true;
+    }
+  }
+
+  if (failed) {
+    process.exit(1);
+  }
+}

package/packages/core/gallery/auth/meta.json

@@ -0,0 +1 @@
+{"name": "Auth", "description": "JWT login form with token display", "try_url": "/gallery/auth"}

package/packages/core/gallery/auth/src/routes/api/gallery/auth/login/post.ts

@@ -0,0 +1,22 @@
+/** Gallery: Auth — login endpoint, returns a JWT token. */
+import type { Tina4Request, Tina4Response } from "@tina4/core";
+
+export default async function (req: Tina4Request, res: Tina4Response) {
+  const body = (req.body as Record<string, unknown>) ?? {};
+  const username = (body.username as string) ?? "";
+  const password = (body.password as string) ?? "";
+
+  if (username && password) {
+    // In a real app: import { Auth } from "@tina4/core";
+    // const auth = new Auth();
+    // const token = auth.createToken({ username, role: "user" });
+    // For the gallery demo, generate a simple base64 token
+    const header = Buffer.from(JSON.stringify({ alg: "HS256", typ: "JWT" })).toString("base64url");
+    const payload = Buffer.from(JSON.stringify({ username, role: "user", iat: Math.floor(Date.now() / 1000) })).toString("base64url");
+    const signature = Buffer.from("gallery-demo-signature").toString("base64url");
+    const token = `${header}.${payload}.${signature}`;
+    return res.json({ token, message: `Welcome ${username}!` });
+  }
+
+  return res.json({ error: "Username and password required" }, 401);
+}