tina4-nodejs 3.12.9 → 3.13.0

package/packages/core/src/static.ts

@@ -27,8 +27,15 @@ export function tryServeStatic(
   req: Tina4Request,
   res: Tina4Response
 ): boolean {
-  const url = req.url ?? "/";
-  const pathname = url.split("?")[0];
+  // Prefer req.path (always path-only, set by createRequest). Fall back to
+  // parsing req.url for hand-rolled request objects in unit tests.
+  let pathname = req.path;
+  if (!pathname) {
+    const raw = req.url ?? "/";
+    pathname = raw.startsWith("http")
+      ? new URL(raw).pathname
+      : raw.split("?")[0];
+  }
 
   // Try exact file match, then index.html for directory requests
   const candidates = [

package/packages/core/src/test.ts

@@ -0,0 +1,246 @@
+/**
+ * Tina4 — The Intelligent Native Application 4ramework
+ * Copyright 2007 - current Tina4
+ * License: MIT https://opensource.org/licenses/MIT
+ *
+ * Tina4 xUnit-style Test base class.
+ *
+ * Chapter 18 of the documentation has long shown:
+ *
+ *     class UserApiTest extends Tina4Test {
+ *       async testHealth() {
+ *         const resp = await this.get("/health");
+ *         this.assertEqual(resp.status, 200);
+ *       }
+ *     }
+ *
+ * Until 3.13.0 this class did not exist — examples crashed with
+ * "ReferenceError: Tina4Test is not defined". This is the Node.js
+ * parity of the Python `tina4_python.test.Test`, PHP `Tina4\Test`,
+ * and Ruby `Tina4::Test` classes shipped at the same time.
+ *
+ * The class has a built-in runner (`Tina4Test.runAll`) so the docs'
+ * `npx tina4nodejs test` flow can discover every subclass without
+ * an external test framework. HTTP helpers (get/post/put/patch/delete)
+ * delegate to a lazy TestClient. Positional assertions match the
+ * cross-framework (actual, expected, message) shape.
+ */
+
+import { TestClient, type TestResponse, type RequestOptions } from "./testClient.js";
+
+// Class-level registry so runAll() can discover every subclass.
+const _subclasses: Array<typeof Tina4Test> = [];
+
+/** Raised by Tina4Test assertion helpers when an assertion fails. */
+export class AssertionError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "AssertionError";
+  }
+}
+
+/** Result of running a Tina4Test subclass (or all subclasses). */
+export interface TestRunResults {
+  passed: number;
+  failed: number;
+  errors: number;
+  details: Array<{
+    suite: string;
+    test: string;
+    status: "passed" | "failed" | "error";
+    message?: string;
+  }>;
+}
+
+/**
+ * Tina4 xUnit-style test base class — class-based suites with HTTP
+ * helpers and positional assertions, zero external deps.
+ *
+ * Subclass and define `test*` methods:
+ *
+ *     class BasicTest extends Tina4Test {
+ *       async testAddition() {
+ *         this.assertEqual(2 + 2, 4, "addition works");
+ *       }
+ *       async testHttpHealth() {
+ *         const resp = await this.get("/health");
+ *         this.assertEqual(resp.status, 200);
+ *       }
+ *     }
+ *
+ *     const results = await Tina4Test.runAll();
+ *     // → { passed, failed, errors, details }
+ */
+export class Tina4Test {
+  private _client: TestClient | null = null;
+
+  // Auto-register every subclass for the runAll() discovery API.
+  // (The static block runs once when the class file loads.)
+  static {
+    // Skip the base class itself
+  }
+
+  /** snake_case lifecycle hook — runs before each test. Override in subclasses. */
+  async setUp(): Promise<void> {}
+
+  /** snake_case lifecycle hook — runs after each test. Override in subclasses. */
+  async tearDown(): Promise<void> {}
+
+  // ── HTTP test client (lazy) ─────────────────────────────────────────
+
+  /** The lazily-created TestClient instance shared by this suite's tests. */
+  protected get client(): TestClient {
+    if (this._client === null) this._client = new TestClient();
+    return this._client;
+  }
+
+  async get(path: string, options?: RequestOptions): Promise<TestResponse> {
+    return this.client.get(path, options);
+  }
+
+  async post(path: string, options?: RequestOptions): Promise<TestResponse> {
+    return this.client.post(path, options);
+  }
+
+  async put(path: string, options?: RequestOptions): Promise<TestResponse> {
+    return this.client.put(path, options);
+  }
+
+  async patch(path: string, options?: RequestOptions): Promise<TestResponse> {
+    return this.client.patch(path, options);
+  }
+
+  async delete(path: string, options?: RequestOptions): Promise<TestResponse> {
+    return this.client.delete(path, options);
+  }
+
+  // ── Positional assertions — (actual, expected, message) shape ────────
+
+  assertEqual(actual: unknown, expected: unknown, message?: string): void {
+    // Deep equality via JSON for objects, strict for primitives — matches
+    // how the Python/PHP/Ruby ports compare.
+    const eq =
+      actual === expected ||
+      (typeof actual === "object" && typeof expected === "object" &&
+        JSON.stringify(actual) === JSON.stringify(expected));
+    if (!eq) {
+      throw new AssertionError(
+        message || `Expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`
+      );
+    }
+  }
+
+  assertNotEqual(actual: unknown, expected: unknown, message?: string): void {
+    const eq =
+      actual === expected ||
+      (typeof actual === "object" && typeof expected === "object" &&
+        JSON.stringify(actual) === JSON.stringify(expected));
+    if (eq) {
+      throw new AssertionError(
+        message || `Expected ${JSON.stringify(actual)} != ${JSON.stringify(expected)}, but they are equal`
+      );
+    }
+  }
+
+  assertTrue(value: unknown, message?: string): void {
+    if (!value) throw new AssertionError(message || `Expected truthy, got ${JSON.stringify(value)}`);
+  }
+
+  assertFalse(value: unknown, message?: string): void {
+    if (value) throw new AssertionError(message || `Expected falsy, got ${JSON.stringify(value)}`);
+  }
+
+  assertNull(value: unknown, message?: string): void {
+    if (value !== null) throw new AssertionError(message || `Expected null, got ${JSON.stringify(value)}`);
+  }
+
+  assertNotNull(value: unknown, message?: string): void {
+    if (value === null) throw new AssertionError(message || "Expected non-null, got null");
+  }
+
+  async assertRaises(
+    expectedClass: new (...args: never[]) => Error,
+    fn: () => unknown | Promise<unknown>,
+    message?: string
+  ): Promise<void> {
+    try {
+      await fn();
+    } catch (err) {
+      if (err instanceof expectedClass) return;
+      throw new AssertionError(
+        message || `Expected ${expectedClass.name}, got ${(err as Error)?.constructor?.name}: ${String(err)}`
+      );
+    }
+    throw new AssertionError(message || `Expected ${expectedClass.name} to be raised, but nothing was`);
+  }
+
+  // ── Runner ───────────────────────────────────────────────────────────
+
+  /** Register a subclass for discovery. Called automatically via `extends Tina4Test`. */
+  static register(klass: typeof Tina4Test): void {
+    if (!_subclasses.includes(klass)) _subclasses.push(klass);
+  }
+
+  /** Run every `test*` method on this class. Returns counts and per-test details. */
+  static async run(this: typeof Tina4Test): Promise<TestRunResults> {
+    const results: TestRunResults = { passed: 0, failed: 0, errors: 0, details: [] };
+    const proto = this.prototype as unknown as Record<string, unknown>;
+    const methods = Object.getOwnPropertyNames(this.prototype)
+      .filter((m) => m.startsWith("test") && typeof proto[m] === "function")
+      .sort();
+
+    for (const method of methods) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const suite = new (this as any)();
+      try {
+        await suite.setUp();
+        await suite[method]();
+        await suite.tearDown();
+        results.passed++;
+        results.details.push({ suite: this.name, test: method, status: "passed" });
+      } catch (err) {
+        if (err instanceof AssertionError) {
+          results.failed++;
+          results.details.push({ suite: this.name, test: method, status: "failed", message: err.message });
+        } else {
+          results.errors++;
+          results.details.push({
+            suite: this.name,
+            test: method,
+            status: "error",
+            message: `${(err as Error)?.constructor?.name || "Error"}: ${String(err)}`,
+          });
+        }
+      }
+    }
+    return results;
+  }
+
+  /** Run every Tina4Test subclass discovered via auto-registration. */
+  static async runAll(options: { quiet?: boolean } = {}): Promise<TestRunResults> {
+    const aggregate: TestRunResults = { passed: 0, failed: 0, errors: 0, details: [] };
+    for (const klass of _subclasses) {
+      const out = await klass.run();
+      aggregate.passed += out.passed;
+      aggregate.failed += out.failed;
+      aggregate.errors += out.errors;
+      aggregate.details.push(...out.details);
+    }
+    if (!options.quiet) {
+      // eslint-disable-next-line no-console
+      console.log(
+        `Tina4 Test results: ${aggregate.passed} passed, ${aggregate.failed} failed, ${aggregate.errors} errors`
+      );
+    }
+    return aggregate;
+  }
+
+  /** Subclasses array — read-only view used by tests. */
+  static get subclasses(): ReadonlyArray<typeof Tina4Test> {
+    return _subclasses;
+  }
+}
+
+// Auto-register subclasses by overriding the `extends` hook. Because JS
+// doesn't have a Ruby/Python-style `inherited` callback, expose `register`
+// as the explicit handshake and document it; tests can call directly.

package/packages/core/src/types.ts

@@ -20,6 +20,24 @@ export interface Tina4Session {
 export interface Tina4Request extends IncomingMessage {
   params: Record<string, string>;
   query: Record<string, string>;
+  /**
+   * Request path only — no query string. Matches `request.path` in
+   * Python/PHP/Ruby. Example: `/users/42`.
+   */
+  path: string;
+  /**
+   * Raw query string with no leading "?". Matches `request.query_string`
+   * (Python/Ruby) and `request.queryString` (PHP). Example: `"page=2"`.
+   */
+  queryString: string;
+  /**
+   * Full absolute URL — `scheme://host[:port]/path[?query]`.
+   * Honours X-Forwarded-Proto / X-Forwarded-Host. Matches PHP/Ruby/Python parity.
+   *
+   * Note: this overrides Node's native `IncomingMessage.url` (which contains
+   * only path+query). Inside Tina4 handlers, `req.url` is always the full URL.
+   */
+  url: string;
   body: unknown;
   ip: string;
   files: Record<string, UploadedFile | UploadedFile[]>;

package/packages/orm/src/database.ts

@@ -869,6 +869,20 @@ export async function initDatabase(config?: DatabaseConfig): Promise<Database> {
   const rawType = config?.type ?? "sqlite";
   const type = rawType === "sqlserver" ? "mssql" : rawType;
 
+  // Loud warning when we hit the default SQLite path because nothing was
+  // configured. Silent fallback was the cause of "my migrations went to the
+  // wrong DB" — the developer thought their .env was being honoured.
+  // Only warn when the caller passed no config AND no env var was set; an
+  // explicit `{ type: "sqlite" }` call is intentional and stays silent.
+  if (config === undefined && !process.env.TINA4_DATABASE_URL) {
+    const path = "./data/tina4.db";
+    console.warn(
+      `[tina4] No TINA4_DATABASE_URL set — falling back to SQLite at ${path}. ` +
+      `If you meant to use Postgres/MySQL/etc., set TINA4_DATABASE_URL in your .env ` +
+      `and re-run. (Was the .env loaded? CLI commands must call loadEnv() first.)`,
+    );
+  }
+
   switch (type) {
     case "sqlite": {
       const { SQLiteAdapter } = await import("./adapters/sqlite.js");