tina4-nodejs 3.0.0-rc.2

package/packages/core/src/request.ts

@@ -0,0 +1,189 @@
+import type { IncomingMessage } from "node:http";
+import type { Tina4Request, UploadedFile } from "./types.js";
+
+export function createRequest(req: IncomingMessage): Tina4Request {
+  const tReq = req as Tina4Request;
+  const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+  const query: Record<string, string> = {};
+  for (const [key, value] of url.searchParams) {
+    query[key] = value;
+  }
+
+  tReq.params = {};
+  tReq.query = query;
+  tReq.body = undefined;
+  tReq.files = [];
+
+  // Determine client IP with X-Forwarded-For support
+  const forwarded = req.headers["x-forwarded-for"];
+  if (typeof forwarded === "string") {
+    tReq.ip = forwarded.split(",")[0].trim();
+  } else if (Array.isArray(forwarded) && forwarded.length > 0) {
+    tReq.ip = forwarded[0].split(",")[0].trim();
+  } else {
+    tReq.ip = req.socket?.remoteAddress ?? "127.0.0.1";
+  }
+
+  return tReq;
+}
+
+export async function parseBody(req: Tina4Request): Promise<void> {
+  const method = req.method?.toUpperCase();
+  if (method === "GET" || method === "HEAD" || method === "OPTIONS") return;
+
+  const contentType = req.headers["content-type"] ?? "";
+  const chunks: Buffer[] = [];
+
+  await new Promise<void>((resolve, reject) => {
+    req.on("data", (chunk: Buffer) => chunks.push(chunk));
+    req.on("end", resolve);
+    req.on("error", reject);
+  });
+
+  const raw = Buffer.concat(chunks);
+  if (raw.length === 0) return;
+
+  if (contentType.includes("multipart/form-data")) {
+    const boundary = extractBoundary(contentType);
+    if (boundary) {
+      const { fields, files } = parseMultipart(raw, boundary);
+      req.body = fields;
+      req.files = files;
+    } else {
+      req.body = raw.toString("utf-8");
+    }
+  } else if (contentType.includes("application/json")) {
+    const str = raw.toString("utf-8");
+    try {
+      req.body = JSON.parse(str);
+    } catch {
+      req.body = str;
+    }
+  } else if (contentType.includes("application/x-www-form-urlencoded")) {
+    const str = raw.toString("utf-8");
+    const params = new URLSearchParams(str);
+    const obj: Record<string, string> = {};
+    for (const [key, value] of params) {
+      obj[key] = value;
+    }
+    req.body = obj;
+  } else {
+    req.body = raw.toString("utf-8");
+  }
+}
+
+/**
+ * Extract the boundary string from a multipart content-type header.
+ */
+function extractBoundary(contentType: string): string | null {
+  const match = contentType.match(/boundary=(?:"([^"]+)"|([^\s;]+))/);
+  return match ? (match[1] ?? match[2]) : null;
+}
+
+/**
+ * Parse multipart/form-data body into fields and files.
+ * Zero-dependency implementation.
+ */
+function parseMultipart(
+  body: Buffer,
+  boundary: string,
+): { fields: Record<string, string>; files: UploadedFile[] } {
+  const fields: Record<string, string> = {};
+  const files: UploadedFile[] = [];
+
+  const delimiter = Buffer.from(`--${boundary}`);
+  const closeDelimiter = Buffer.from(`--${boundary}--`);
+  const crlf = Buffer.from("\r\n");
+  const doubleCrlf = Buffer.from("\r\n\r\n");
+
+  let offset = 0;
+
+  // Find first delimiter
+  const firstIdx = bufferIndexOf(body, delimiter, offset);
+  if (firstIdx === -1) return { fields, files };
+  offset = firstIdx + delimiter.length;
+
+  // Skip CRLF after delimiter
+  if (body[offset] === 0x0d && body[offset + 1] === 0x0a) {
+    offset += 2;
+  }
+
+  while (offset < body.length) {
+    // Find the end of headers (double CRLF)
+    const headersEnd = bufferIndexOf(body, doubleCrlf, offset);
+    if (headersEnd === -1) break;
+
+    const headersStr = body.subarray(offset, headersEnd).toString("utf-8");
+    offset = headersEnd + doubleCrlf.length;
+
+    // Find next delimiter
+    const nextDelimIdx = bufferIndexOf(body, delimiter, offset);
+    if (nextDelimIdx === -1) break;
+
+    // Content data is between current offset and nextDelimIdx - CRLF
+    const contentEnd = nextDelimIdx - crlf.length;
+    const content = body.subarray(offset, contentEnd);
+
+    // Parse headers
+    const disposition = parseDisposition(headersStr);
+    const partContentType = parsePartContentType(headersStr);
+
+    if (disposition.filename) {
+      // File upload
+      files.push({
+        fieldName: disposition.name,
+        filename: disposition.filename,
+        contentType: partContentType ?? "application/octet-stream",
+        data: Buffer.from(content),
+        size: content.length,
+      });
+    } else if (disposition.name) {
+      // Regular field
+      fields[disposition.name] = content.toString("utf-8");
+    }
+
+    // Move past the delimiter
+    offset = nextDelimIdx + delimiter.length;
+
+    // Check for close delimiter
+    if (body[offset] === 0x2d && body[offset + 1] === 0x2d) {
+      // "--" means end of multipart
+      break;
+    }
+
+    // Skip CRLF after delimiter
+    if (body[offset] === 0x0d && body[offset + 1] === 0x0a) {
+      offset += 2;
+    }
+  }
+
+  return { fields, files };
+}
+
+function bufferIndexOf(haystack: Buffer, needle: Buffer, offset: number): number {
+  for (let i = offset; i <= haystack.length - needle.length; i++) {
+    let found = true;
+    for (let j = 0; j < needle.length; j++) {
+      if (haystack[i + j] !== needle[j]) {
+        found = false;
+        break;
+      }
+    }
+    if (found) return i;
+  }
+  return -1;
+}
+
+function parseDisposition(headers: string): { name: string; filename?: string } {
+  const nameMatch = headers.match(/name="([^"]+)"/);
+  const filenameMatch = headers.match(/filename="([^"]+)"/);
+  return {
+    name: nameMatch?.[1] ?? "",
+    filename: filenameMatch?.[1],
+  };
+}
+
+function parsePartContentType(headers: string): string | null {
+  const match = headers.match(/Content-Type:\s*(.+?)(?:\r?\n|$)/i);
+  return match?.[1]?.trim() ?? null;
+}

package/packages/core/src/response.ts

@@ -0,0 +1,146 @@
+import type { ServerResponse } from "node:http";
+import type { Tina4Response, CookieOptions } from "./types.js";
+
+/**
+ * Creates a callable response object.
+ *
+ *   return response({ users: [] });                    // Auto-JSON
+ *   return response({ ok: true }, HTTP_CREATED);       // JSON with status
+ *   return response("<h1>Hi</h1>");                    // Auto-HTML
+ *   return response("Not found", HTTP_NOT_FOUND);      // Plain text
+ *   return response(data, HTTP_OK, APPLICATION_JSON);  // Explicit
+ *   return response.json(data, 201);                   // Method
+ *   return response.redirect("/login");                // Special
+ */
+export function createResponse(res: ServerResponse): Tina4Response {
+
+  // ── The callable: response(data, status, contentType) ──
+  const response = function (data?: unknown, statusCode?: number, contentType?: string): Tina4Response {
+    if (statusCode !== undefined) {
+      res.statusCode = statusCode;
+    }
+
+    if (contentType) {
+      // Explicit content type
+      res.setHeader("Content-Type", contentType);
+      if (typeof data === "object" && data !== null && !Buffer.isBuffer(data)) {
+        res.end(JSON.stringify(data));
+      } else {
+        res.end(data == null ? "" : String(data));
+      }
+    } else if (typeof data === "object" && data !== null && !Buffer.isBuffer(data)) {
+      // dict/array → auto JSON
+      res.setHeader("Content-Type", "application/json");
+      res.end(JSON.stringify(data));
+    } else if (typeof data === "string") {
+      const trimmed = data.trim();
+      if (trimmed.startsWith("<") && trimmed.endsWith(">")) {
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+      } else {
+        res.setHeader("Content-Type", "text/plain; charset=utf-8");
+      }
+      res.end(data);
+    } else if (Buffer.isBuffer(data)) {
+      if (!res.getHeader("Content-Type")) {
+        res.setHeader("Content-Type", "application/octet-stream");
+      }
+      res.end(data);
+    } else if (data == null) {
+      res.end("");
+    } else {
+      res.setHeader("Content-Type", "text/plain; charset=utf-8");
+      res.end(String(data));
+    }
+
+    return response;
+  } as Tina4Response;
+
+  // ── Attach the underlying ServerResponse ──
+  response.raw = res;
+
+  // ── Explicit methods ──
+
+  response.json = function (data: unknown, status?: number): Tina4Response {
+    if (status !== undefined) res.statusCode = status;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(data));
+    return response;
+  };
+
+  response.html = function (content: string, status?: number): Tina4Response {
+    if (status !== undefined) res.statusCode = status;
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    res.end(content);
+    return response;
+  };
+
+  response.text = function (content: string, status?: number): Tina4Response {
+    if (status !== undefined) res.statusCode = status;
+    res.setHeader("Content-Type", "text/plain; charset=utf-8");
+    res.end(content);
+    return response;
+  };
+
+  response.send = function (data: unknown, statusCode?: number, contentType?: string): Tina4Response {
+    return response(data, statusCode, contentType);
+  };
+
+  response.status = function (code: number): Tina4Response {
+    res.statusCode = code;
+    return response;
+  };
+
+  response.header = function (name: string, value: string | number | readonly string[]): Tina4Response {
+    res.setHeader(name, value);
+    return response;
+  };
+
+  response.redirect = function (url: string, code?: number): Tina4Response {
+    res.statusCode = code ?? 302;
+    res.setHeader("Location", url);
+    res.end();
+    return response;
+  };
+
+  response.cookie = function (name: string, value: string, options?: CookieOptions): Tina4Response {
+    const parts = [`${encodeURIComponent(name)}=${encodeURIComponent(value)}`];
+    if (options?.maxAge !== undefined) parts.push(`Max-Age=${options.maxAge}`);
+    if (options?.expires) parts.push(`Expires=${options.expires.toUTCString()}`);
+    if (options?.path) parts.push(`Path=${options.path}`);
+    if (options?.domain) parts.push(`Domain=${options.domain}`);
+    if (options?.secure) parts.push("Secure");
+    if (options?.httpOnly) parts.push("HttpOnly");
+    if (options?.sameSite) parts.push(`SameSite=${options.sameSite}`);
+
+    const existing = res.getHeader("Set-Cookie");
+    const cookies: string[] = [];
+    if (Array.isArray(existing)) cookies.push(...(existing as string[]));
+    else if (typeof existing === "string") cookies.push(existing);
+    cookies.push(parts.join("; "));
+    res.setHeader("Set-Cookie", cookies);
+
+    return response;
+  };
+
+  response.clearCookie = function (name: string, options?: CookieOptions): Tina4Response {
+    return response.cookie(name, "", { ...options, maxAge: 0, expires: new Date(0) });
+  };
+
+  response.template = async function (name: string, data?: Record<string, unknown>): Promise<Tina4Response> {
+    try {
+      const twig = await import("@tina4/twig");
+      const html = await twig.renderTemplate(name, data);
+      response.html(html);
+    } catch (err) {
+      res.statusCode = 500;
+      response.json({
+        error: "Template rendering failed",
+        statusCode: 500,
+        message: String(err),
+      });
+    }
+    return response;
+  };
+
+  return response;
+}

package/packages/core/src/routeDiscovery.ts

@@ -0,0 +1,87 @@
+import { readdirSync, statSync } from "node:fs";
+import { join, relative, basename, extname } from "node:path";
+import type { RouteDefinition, RouteHandler, RouteMeta } from "./types.js";
+
+const VALID_METHODS = new Set(["get", "post", "put", "delete", "patch"]);
+
+export async function discoverRoutes(routesDir: string): Promise<RouteDefinition[]> {
+  const definitions: RouteDefinition[] = [];
+  const files = walkDir(routesDir);
+
+  for (const filePath of files) {
+    const ext = extname(filePath);
+    if (ext !== ".ts" && ext !== ".js") continue;
+
+    const name = basename(filePath, ext).toLowerCase();
+    if (!VALID_METHODS.has(name)) continue;
+
+    const method = name.toUpperCase();
+    const relativePath = relative(routesDir, filePath);
+    const pattern = filePathToPattern(relativePath);
+
+    try {
+      // Cache-bust for hot-reload
+      const moduleUrl = `file://${filePath}?t=${Date.now()}`;
+      const mod = await import(moduleUrl);
+
+      const handler: RouteHandler = mod.default ?? mod.handler;
+      if (typeof handler !== "function") {
+        console.warn(`  Warning: ${relativePath} does not export a handler function, skipping`);
+        continue;
+      }
+
+      const meta: RouteMeta | undefined = mod.meta;
+      const template: string | undefined = typeof mod.template === "string" ? mod.template : undefined;
+
+      definitions.push({ method, pattern, handler, filePath, meta, template });
+    } catch (err) {
+      console.error(`  Error loading route ${relativePath}:`, err);
+    }
+  }
+
+  return definitions;
+}
+
+function filePathToPattern(relativePath: string): string {
+  // Remove the filename (get.ts, post.ts, etc.) to get the directory path
+  const parts = relativePath.split("/").slice(0, -1);
+
+  // Convert directory segments to URL pattern
+  // File system uses [id] notation, but URL patterns use {id} to match Python
+  const urlParts = parts.map((part) => {
+    if (part.startsWith("[...") && part.endsWith("]")) {
+      // Catch-all: [...slug] -> {...slug}
+      const name = part.slice(4, -1);
+      return `{...${name}}`;
+    }
+    if (part.startsWith("[") && part.endsWith("]")) {
+      // Dynamic param: [id] -> {id}
+      const name = part.slice(1, -1);
+      return `{${name}}`;
+    }
+    return part;
+  });
+
+  return "/" + urlParts.join("/");
+}
+
+function walkDir(dir: string): string[] {
+  const files: string[] = [];
+
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        files.push(...walkDir(fullPath));
+      } else {
+        files.push(fullPath);
+      }
+    }
+  } catch {
+    // Directory doesn't exist yet, that's fine
+  }
+
+  return files;
+}