create-jen-app 1.2.3 → 1.2.4

package/templates/static/lib/core/routes/orchestrator.js

@@ -0,0 +1,171 @@
+import { matchRoute } from "./match.js";
+import {
+  getAdvancedRouteConfig,
+  validateQueryParams,
+  processQueryParams,
+} from "./advanced.js";
+import {
+  getRedirect,
+  getNotFoundHandler,
+  send404,
+  sendRedirect,
+  createDefault404Html,
+} from "./handlers.js";
+import { log } from "../../shared/log.js";
+/**
+ * Advanced routing orchestrator that handles:
+ * - Dynamic route matching with parameter extraction
+ * - Query parameter parsing and validation
+ * - Catch-all routes
+ * - Middleware guards
+ * - Redirects (app-level and route-level)
+ * - 404 handling
+ */
+export class AdvancedRouter {
+  routes;
+  config;
+  constructor(routes, config) {
+    this.routes = routes;
+    this.config = config;
+  }
+  /**
+   * Resolve a request pathname to a route match, redirect, or 404
+   *
+   * @param pathname URL pathname
+   * @param url Full URL object
+   * @param headers Request headers
+   * @param cookies Parsed cookies
+   * @returns Route resolution result
+   */
+  async resolve(pathname, url, headers, cookies) {
+    log.info(`[Router] Resolving: ${pathname}`);
+    // Step 1: Check application-level redirects
+    if (this.config.redirects) {
+      const redirect = getRedirect(pathname, this.config.redirects);
+      if (redirect) {
+        log.info(`[Router] Redirect: ${pathname} -> ${redirect.to}`);
+        return {
+          type: "redirect",
+          location: redirect.to,
+          status: redirect.status,
+        };
+      }
+    }
+    // Step 2: Match against routes
+    const match = matchRoute(this.routes, pathname);
+    if (!match) {
+      log.info(`[Router] No route match for: ${pathname}`);
+      return { type: "not_found", pathname };
+    }
+    // Parse query parameters
+    const query = {};
+    for (const [k, v] of url.searchParams.entries()) query[k] = v;
+    // Step 3: Load advanced route config
+    const advancedConfig = await getAdvancedRouteConfig(match.route.filePath);
+    // Step 4: Handle route-level redirects
+    if (advancedConfig.redirect) {
+      const guardCtx = {
+        route: match.route,
+        params: match.params,
+        query,
+        url,
+        headers,
+        cookies,
+      };
+      const target =
+        typeof advancedConfig.redirect.to === "function"
+          ? advancedConfig.redirect.to(guardCtx)
+          : advancedConfig.redirect.to;
+      const status = advancedConfig.redirect.status ?? 301;
+      log.info(`[Router] Route redirect: ${pathname} -> ${target} (${status})`);
+      return {
+        type: "redirect",
+        location: target,
+        status,
+      };
+    }
+    // Step 5: Validate query parameters
+    if (advancedConfig.querySchema) {
+      const validation = validateQueryParams(query, advancedConfig.querySchema);
+      if (!validation.valid) {
+        log.warn(
+          `[Router] Query validation failed: ${validation.errors.join(", ")}`,
+        );
+        // For now, log but don't block. In strict mode, this could return 400.
+      }
+      // Apply defaults and type coercion
+      const processed = processQueryParams(query, advancedConfig.querySchema);
+      Object.assign(query, processed);
+    }
+    // Step 6: Run middleware guards
+    if (advancedConfig.guards && advancedConfig.guards.length > 0) {
+      const guardCtx = {
+        route: match.route,
+        params: match.params,
+        query,
+        url,
+        headers,
+        cookies,
+      };
+      for (const guard of advancedConfig.guards) {
+        const result = await guard(guardCtx);
+        if (result !== true) {
+          // Guard blocked or redirected
+          log.info(
+            `[Router] Guard blocked: ${pathname} (status: ${result.status})`,
+          );
+          return {
+            type: "redirect",
+            location: result.location || "/",
+            status: result.status,
+          };
+        }
+      }
+    }
+    log.info(`[Router] Matched: ${pathname} -> ${match.route.urlPath}`);
+    return {
+      type: "matched",
+      route: match.route,
+      params: match.params,
+      query,
+    };
+  }
+  /**
+   * Handle a 404 response
+   *
+   * @param res ServerResponse object
+   * @param pathname Path that was not found
+   */
+  async handle404(res, pathname) {
+    const notFoundConfig = getNotFoundHandler(this.config, pathname);
+    if (notFoundConfig) {
+      log.info(`[Router] Using custom 404 handler for: ${pathname}`);
+      send404(res, notFoundConfig, pathname);
+    } else {
+      log.info(`[Router] Using default 404 handler for: ${pathname}`);
+      const html = createDefault404Html(pathname);
+      send404(res, { html }, pathname);
+    }
+  }
+  /**
+   * Handle a redirect response
+   *
+   * @param res ServerResponse object
+   * @param location Target URL
+   * @param status HTTP status code
+   */
+  handleRedirect(res, location, status) {
+    log.info(`[Router] Sending redirect: ${location} (${status})`);
+    sendRedirect(res, location, status);
+  }
+}
+/**
+ * Create an advanced router from framework config and routes
+ *
+ * @param routes Scanned route entries
+ * @param config Framework configuration
+ * @returns AdvancedRouter instance
+ */
+export function createAdvancedRouter(routes, config) {
+  return new AdvancedRouter(routes, config);
+}

package/templates/static/lib/core/routes/rendering-config.js

@@ -0,0 +1,131 @@
+/**
+ * Route-level rendering configuration detection
+ *
+ * Allows routes to specify their rendering strategy via exported config:
+ *
+ * @example
+ * // pages/(home).tsx
+ * export const rendering = "ssg";
+ * export const revalidate = 3600; // ISR revalidation in seconds
+ *
+ * export default function Home() { ... }
+ */
+/**
+ * Extract rendering configuration from a route module.
+ * Safely handles modules that don't specify rendering config.
+ *
+ * @param module Route module (imported component)
+ * @param defaultMode Default rendering mode if not specified
+ * @param defaultRevalidate Default revalidation seconds for ISR
+ * @returns Route rendering configuration
+ */
+export function extractRenderingConfig(
+  module,
+  defaultMode = "ssg",
+  defaultRevalidate = 3600,
+) {
+  const mode = module?.rendering || defaultMode;
+  // Validate mode
+  const validModes = ["ssg", "ssr", "isr", "ppr"];
+  if (!validModes.includes(mode)) {
+    console.warn(
+      `Invalid rendering mode: ${mode}, defaulting to ${defaultMode}`,
+    );
+    return { mode: defaultMode, revalidateSeconds: defaultRevalidate };
+  }
+  // Extract revalidation time if mode is ISR
+  let revalidateSeconds;
+  if (mode === "isr") {
+    revalidateSeconds =
+      typeof module?.revalidate === "number"
+        ? module.revalidate
+        : defaultRevalidate;
+  }
+  return { mode, revalidateSeconds };
+}
+/**
+ * Cached rendering configs to avoid repeated module evaluations.
+ * Maps file path → rendering config.
+ */
+const configCache = new Map();
+/**
+ * Clear the rendering config cache.
+ * Useful during development when routes change.
+ */
+export function clearRenderingConfigCache() {
+  configCache.clear();
+}
+/**
+ * Get rendering config for a route, with caching.
+ * Attempts to dynamically import and evaluate the route module.
+ *
+ * In a production SSR environment, route modules are pre-compiled.
+ * In a build environment, we need to safely evaluate modules.
+ *
+ * @param filePath Absolute path to route file
+ * @param defaultMode Default rendering mode
+ * @param defaultRevalidate Default revalidation seconds
+ * @returns Rendering configuration promise
+ */
+export async function getRenderingConfig(
+  filePath,
+  defaultMode = "ssg",
+  defaultRevalidate = 3600,
+) {
+  // Check cache first
+  if (configCache.has(filePath)) {
+    return configCache.get(filePath);
+  }
+  try {
+    // Attempt to import the module
+    // This works in ESM environments with proper module resolution
+    const module = await import(`file://${filePath}`);
+    const config = extractRenderingConfig(
+      module,
+      defaultMode,
+      defaultRevalidate,
+    );
+    // Cache for future lookups
+    configCache.set(filePath, config);
+    return config;
+  } catch (err) {
+    // If import fails, return default config
+    // This can happen if module has syntax errors or imports unavailable at build time
+    const config = {
+      mode: defaultMode,
+      revalidateSeconds: defaultMode === "isr" ? defaultRevalidate : undefined,
+    };
+    configCache.set(filePath, config);
+    return config;
+  }
+}
+/**
+ * Synchronously get rendering config (for build-time use).
+ * Falls back to default if module can't be imported.
+ *
+ * Note: This uses a synchronous require-like approach and may not work
+ * in all environments. Prefer async getRenderingConfig() when possible.
+ *
+ * @param filePath Absolute path to route file
+ * @param defaultMode Default rendering mode
+ * @param defaultRevalidate Default revalidation seconds
+ * @returns Rendering configuration
+ */
+export function getRenderingConfigSync(
+  filePath,
+  defaultMode = "ssg",
+  defaultRevalidate = 3600,
+) {
+  // Check cache first
+  if (configCache.has(filePath)) {
+    return configCache.get(filePath);
+  }
+  // In sync context, we can't dynamically import
+  // Return default config
+  const config = {
+    mode: defaultMode,
+    revalidateSeconds: defaultMode === "isr" ? defaultRevalidate : undefined,
+  };
+  configCache.set(filePath, config);
+  return config;
+}

package/templates/static/lib/core/routes/scan.js

@@ -1,20 +1,3 @@
-/*
- * This file is part of Jen.js.
- * Copyright (C) 2026 oopsio
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */
 import { readdirSync, statSync } from "node:fs";
 import { join, relative, sep } from "node:path";
 /**

package/templates/static/lib/core/types.js

@@ -1,18 +1 @@
-/*
- * This file is part of Jen.js.
- * Copyright (C) 2026 oopsio
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */
 export {};

package/templates/static/lib/css/compiler.js

@@ -1,22 +1,5 @@
-/*
- * This file is part of Jen.js.
- * Copyright (C) 2026 oopsio
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */
 import { compile, compileString } from "sass";
-import { globSync } from "glob";
+import { globSync } from "../vendor/glob/glob.js";
 import { writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
 import { log } from "../shared/log.js";

package/templates/static/lib/data-fetching/cache.js

@@ -0,0 +1,223 @@
+/**
+ * In-memory cache implementation for data fetching.
+ * Supports TTL-based expiration and tag-based invalidation.
+ * Suitable for development and single-process deployments.
+ */
+export class MemoryDataCache {
+  store = new Map();
+  tags = new Map();
+  /**
+   * Retrieves a cached value by key.
+   * Returns null if key doesn't exist or entry has expired.
+   */
+  async get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return null;
+    // Check expiration
+    const now = Date.now();
+    if (now - entry.timestamp > entry.ttl) {
+      this.store.delete(key);
+      this.cleanupTags(key);
+      return null;
+    }
+    return entry.data;
+  }
+  /**
+   * Stores a value in cache with optional TTL and tags.
+   */
+  async set(
+    key,
+    value,
+    ttl = 60000, // 1 minute default
+    tags,
+  ) {
+    const entry = {
+      data: value,
+      timestamp: Date.now(),
+      ttl,
+      tags,
+    };
+    this.store.set(key, entry);
+    // Register tags for invalidation
+    if (tags) {
+      for (const tag of tags) {
+        if (!this.tags.has(tag)) {
+          this.tags.set(tag, new Set());
+        }
+        this.tags.get(tag).add(key);
+      }
+    }
+  }
+  /**
+   * Deletes a specific cache entry.
+   */
+  async delete(key) {
+    this.store.delete(key);
+    this.cleanupTags(key);
+  }
+  /**
+   * Clears all cache entries.
+   */
+  async clear() {
+    this.store.clear();
+    this.tags.clear();
+  }
+  /**
+   * Invalidates all cache entries with specified tags.
+   * Useful for mass cache busting after data mutations.
+   */
+  async invalidate(tags) {
+    const keysToDelete = new Set();
+    for (const tag of tags) {
+      const keys = this.tags.get(tag);
+      if (keys) {
+        for (const key of keys) {
+          keysToDelete.add(key);
+        }
+      }
+    }
+    for (const key of keysToDelete) {
+      this.store.delete(key);
+    }
+    // Clean up tag mappings
+    for (const tag of tags) {
+      this.tags.delete(tag);
+    }
+  }
+  /**
+   * Internal helper to clean up tag references when a key is deleted.
+   */
+  cleanupTags(key) {
+    for (const keySet of this.tags.values()) {
+      keySet.delete(key);
+    }
+  }
+  /**
+   * Returns cache statistics for debugging.
+   */
+  getStats() {
+    return {
+      size: this.store.size,
+      tags: this.tags.size,
+      memory: this.estimateMemory(),
+    };
+  }
+  /**
+   * Rough estimate of memory usage (for monitoring).
+   */
+  estimateMemory() {
+    let bytes = 0;
+    for (const [key, entry] of this.store) {
+      bytes += key.length * 2; // Rough UTF-16 estimate
+      bytes += JSON.stringify(entry.data).length;
+    }
+    return bytes;
+  }
+}
+/**
+ * NoOp cache implementation that doesn't cache anything.
+ * Used when caching is disabled or for testing.
+ */
+export class NoOpCache {
+  async get() {
+    return null;
+  }
+  async set() {
+    // No-op
+  }
+  async delete() {
+    // No-op
+  }
+  async clear() {
+    // No-op
+  }
+  async invalidate() {
+    // No-op
+  }
+}
+/**
+ * Creates a cache key from a URL and optional parameters.
+ * Ensures consistent key generation across requests.
+ */
+export function createCacheKey(url, options) {
+  let key = url;
+  if (options?.method && options.method !== "GET") {
+    key += `|${options.method}`;
+  }
+  if (options?.body) {
+    const bodyStr =
+      typeof options.body === "string"
+        ? options.body
+        : JSON.stringify(options.body);
+    key += `|${hashString(bodyStr)}`;
+  }
+  if (options?.headers) {
+    const headerStr = JSON.stringify(options.headers);
+    key += `|${hashString(headerStr)}`;
+  }
+  return key;
+}
+/**
+ * Simple hash function for generating consistent cache keys.
+ */
+function hashString(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash; // Convert to 32bit integer
+  }
+  return Math.abs(hash).toString(36);
+}
+/**
+ * Cache strategy executor for handling different cache modes.
+ */
+export async function executeCacheStrategy(
+  strategy,
+  { key, cache, fetchFn, ttl = 60000, tags },
+) {
+  switch (strategy) {
+    case "cache-first": {
+      const cached = await cache.get(key);
+      if (cached !== null) {
+        return { data: cached, cached: true };
+      }
+      const fresh = await fetchFn();
+      await cache.set(key, fresh, ttl, tags);
+      return { data: fresh, cached: false };
+    }
+    case "network-first": {
+      try {
+        const fresh = await fetchFn();
+        await cache.set(key, fresh, ttl, tags);
+        return { data: fresh, cached: false };
+      } catch (error) {
+        const cached = await cache.get(key);
+        if (cached !== null) {
+          return { data: cached, cached: true };
+        }
+        throw error;
+      }
+    }
+    case "stale-while-revalidate": {
+      const cached = await cache.get(key);
+      // Return cached immediately, revalidate in background
+      if (cached !== null) {
+        fetchFn()
+          .then((fresh) => cache.set(key, fresh, ttl, tags))
+          .catch(() => {
+            /* Silently fail background revalidation */
+          });
+        return { data: cached, cached: true };
+      }
+      const fresh = await fetchFn();
+      await cache.set(key, fresh, ttl, tags);
+      return { data: fresh, cached: false };
+    }
+    case "no-cache":
+    default: {
+      const fresh = await fetchFn();
+      return { data: fresh, cached: false };
+    }
+  }
+}