create-jen-app 1.2.2 → 1.2.4

package/templates/static/lib/server-actions/scan.js

@@ -0,0 +1,152 @@
+import { readdirSync, statSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+/**
+ * Recursively walks a directory and returns all file paths.
+ * Used to discover all action files in the actions directory.
+ */
+function walk(dir) {
+  const out = [];
+  try {
+    for (const name of readdirSync(dir)) {
+      const p = join(dir, name);
+      const st = statSync(p);
+      if (st.isDirectory()) out.push(...walk(p));
+      else out.push(p);
+    }
+  } catch {
+    // Directory doesn't exist yet
+  }
+  return out;
+}
+/**
+ * Normalizes filesystem path separators to forward slashes.
+ */
+function normalizeSlashes(p) {
+  return p.split(sep).join("/");
+}
+/**
+ * Converts kebab-case to camelCase.
+ */
+function kebabToCamel(str) {
+  return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+}
+/**
+ * Converts a file path to an action name.
+ * - actions/post-comment.ts => postComment
+ * - actions/blog/publish.ts => blog.publish
+ * - actions/deeply/nested/action.ts => deeply.nested.action
+ */
+function filePathToActionName(filePath) {
+  // Remove extension
+  const withoutExt = filePath.replace(/\.(ts|js|tsx|jsx)$/, "");
+  // Split by directory separator
+  const parts = withoutExt.split("/");
+  // Convert each part from kebab-case to camelCase, except keep first as-is for namespace
+  return parts
+    .map((part, idx) => {
+      // First part can be namespace (keep as-is)
+      // Subsequent parts are action names (convert to camelCase)
+      return idx === 0 ? part : kebabToCamel(part);
+    })
+    .join(".");
+}
+/**
+ * Scans the actions directory for server action files.
+ * Server action files are TypeScript/JavaScript files in the site/actions directory.
+ * Each file should export a default function that is the action handler.
+ *
+ * Naming conventions:
+ * - actions/submit-form.ts => action path /submit-form, name "submitForm"
+ * - actions/blog/publish.ts => action path /blog/publish, name "blog.publish"
+ * - actions/user/[id]/delete.ts => action path /user/:id/delete, name "user.delete"
+ *
+ * @param config Framework configuration with siteDir
+ * @returns Array of ServerActionEntry objects for all discovered actions
+ */
+export function scanServerActions(config) {
+  const actionsDir = join(process.cwd(), config.siteDir, "actions");
+  const files = walk(actionsDir);
+  const actions = [];
+  for (const abs of files) {
+    // Skip if not a valid action file
+    const ext = abs.split(".").pop()?.toLowerCase();
+    if (!ext || !["ts", "js", "tsx", "jsx"].includes(ext)) {
+      continue;
+    }
+    // Get relative path from actions directory
+    const rel = normalizeSlashes(relative(actionsDir, abs));
+    // Remove extension
+    const withoutExt = rel.replace(/\.(ts|js|tsx|jsx)$/, "");
+    // Convert file path to action path
+    // Handle dynamic segments: [id] => :id
+    const actionPath =
+      "/" +
+      withoutExt
+        .split("/")
+        .map((part) =>
+          part.startsWith("[") && part.endsWith("]")
+            ? ":" + part.slice(1, -1)
+            : part,
+        )
+        .join("/");
+    // Generate action name
+    const actionName = filePathToActionName(withoutExt);
+    actions.push({
+      id: withoutExt.replaceAll("/", "_").replaceAll("-", "_"),
+      filePath: abs,
+      actionPath,
+      name: actionName,
+    });
+  }
+  // Sort by path specificity (static first, then dynamic)
+  actions.sort((a, b) => {
+    const aDyn = a.actionPath.includes(":");
+    const bDyn = b.actionPath.includes(":");
+    if (aDyn !== bDyn) return aDyn ? 1 : -1;
+    return a.actionPath.localeCompare(b.actionPath);
+  });
+  return actions;
+}
+/**
+ * Matches an action path against discovered server actions.
+ * Handles static and dynamic route matching.
+ *
+ * @param actions Array of discovered server actions
+ * @param requestPath The incoming request path
+ * @returns Matched action entry with params if found, null otherwise
+ */
+export function matchServerAction(actions, requestPath) {
+  // Normalize path
+  const path = requestPath.startsWith("/") ? requestPath : "/" + requestPath;
+  for (const action of actions) {
+    // Try exact match first
+    if (action.actionPath === path) {
+      return { action, params: {} };
+    }
+    // Try dynamic match
+    const actionParts = action.actionPath.split("/").filter(Boolean);
+    const pathParts = path.split("/").filter(Boolean);
+    if (actionParts.length !== pathParts.length) {
+      continue;
+    }
+    const params = {};
+    let matches = true;
+    for (let i = 0; i < actionParts.length; i++) {
+      const actionPart = actionParts[i];
+      const pathPart = pathParts[i];
+      if (actionPart.startsWith(":")) {
+        // Dynamic segment
+        const paramName = actionPart.slice(1);
+        params[paramName] = pathPart;
+      } else if (actionPart !== pathPart) {
+        // Static segment doesn't match
+        matches = false;
+        break;
+      }
+    }
+    if (matches) {
+      return { action, params };
+    }
+  }
+  return null;
+}

package/templates/static/lib/server-actions/types.js

@@ -0,0 +1 @@
+export {};

package/templates/static/lib/server-actions/validators.js

@@ -0,0 +1,156 @@
+/**
+ * Common validation rules for server actions.
+ * Can be composed and chained for complex validations.
+ */
+/**
+ * Creates a required field validator.
+ * Checks that value is not null, undefined, or empty string.
+ */
+export function required(message = "This field is required") {
+  return {
+    name: "required",
+    validate: (value) => {
+      if (value === null || value === undefined || value === "") {
+        return message;
+      }
+      return undefined;
+    },
+  };
+}
+/**
+ * Creates a minimum length validator for strings.
+ */
+export function minLength(min, message) {
+  return {
+    name: "minLength",
+    validate: (value) => {
+      if (typeof value !== "string") return undefined;
+      if (value.length < min) {
+        return message || `Minimum ${min} characters required`;
+      }
+      return undefined;
+    },
+  };
+}
+/**
+ * Creates a maximum length validator for strings.
+ */
+export function maxLength(max, message) {
+  return {
+    name: "maxLength",
+    validate: (value) => {
+      if (typeof value !== "string") return undefined;
+      if (value.length > max) {
+        return message || `Maximum ${max} characters allowed`;
+      }
+      return undefined;
+    },
+  };
+}
+/**
+ * Creates an email format validator.
+ */
+export function email(message = "Invalid email address") {
+  return {
+    name: "email",
+    validate: (value) => {
+      if (typeof value !== "string" || !value) return undefined;
+      // Simple email regex (RFC 5322 simplified)
+      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+      if (!emailRegex.test(value)) {
+        return message;
+      }
+      return undefined;
+    },
+  };
+}
+/**
+ * Creates a URL format validator.
+ */
+export function url(message = "Invalid URL") {
+  return {
+    name: "url",
+    validate: (value) => {
+      if (typeof value !== "string" || !value) return undefined;
+      try {
+        new URL(value);
+        return undefined;
+      } catch {
+        return message;
+      }
+    },
+  };
+}
+/**
+ * Creates a regex pattern validator.
+ */
+export function pattern(regex, message) {
+  return {
+    name: "pattern",
+    validate: (value) => {
+      if (typeof value !== "string" || !value) return undefined;
+      if (!regex.test(value)) {
+        return message || "Invalid format";
+      }
+      return undefined;
+    },
+  };
+}
+/**
+ * Creates a number range validator.
+ */
+export function range(min, max, message) {
+  return {
+    name: "range",
+    validate: (value) => {
+      const num = Number(value);
+      if (isNaN(num)) return undefined;
+      if (num < min || num > max) {
+        return message || `Must be between ${min} and ${max}`;
+      }
+      return undefined;
+    },
+  };
+}
+/**
+ * Creates a custom validator from a function.
+ */
+export function custom(fn, message = "Invalid value") {
+  return {
+    name: "custom",
+    validate: (value) => {
+      const result = fn(value);
+      if (result === false) return message;
+      if (typeof result === "string") return result;
+      return undefined;
+    },
+  };
+}
+/**
+ * Creates an enum validator.
+ */
+export function enumValue(values, message) {
+  return {
+    name: "enum",
+    validate: (value) => {
+      if (!values.includes(value)) {
+        return message || `Must be one of: ${values.join(", ")}`;
+      }
+      return undefined;
+    },
+  };
+}
+/**
+ * Creates a type validator.
+ */
+export function type(expectedType, message) {
+  return {
+    name: "type",
+    validate: (value) => {
+      if (typeof value !== expectedType) {
+        return message || `Expected ${expectedType}`;
+      }
+      return undefined;
+    },
+  };
+}

package/templates/static/lib/shared/log.js

@@ -1,31 +1,80 @@
-/*
- * 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.
+// ANSI color codes
+const colors = {
+  reset: "\x1b[0m",
+  dim: "\x1b[2m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  cyan: "\x1b[36m",
+  bold: "\x1b[1m",
+};
+/**
+ * Get current timestamp in ISO 8601 format.
+ * Used to prefix all log messages with precise UTC time information for debugging and monitoring.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ * @returns ISO 8601 timestamp string (e.g., "2026-02-19T15:30:45.123Z")
  */
 function ts() {
-    return new Date().toISOString();
+  return new Date().toISOString();
 }
+/**
+ * Structured logging utility for the Jen.js framework.
+ * Provides three log levels (info, warn, error) that output to appropriate streams.
+ *
+ * Usage:
+ * - log.info(): Development and progress messages
+ * - log.warn(): Warnings and non-fatal issues
+ * - log.error(): Critical errors that may require attention
+ *
+ * Format:
+ * All logs include an ISO 8601 timestamp and a level prefix.
+ * Example: "[2026-02-19T15:30:45.123Z] [INFO] Building 42 routes"
+ *
+ * Output:
+ * - info() -> console.log (stdout)
+ * - warn() -> console.warn (stderr)
+ * - error() -> console.error (stderr)
+ *
+ * This is used throughout the framework for build output, server status, and diagnostics.
+ */
 export const log = {
-    info(msg) {
-        console.log(`[${ts()}] [INFO] ${msg}`);
-    },
-    warn(msg) {
-        console.warn(`[${ts()}] [WARN] ${msg}`);
-    },
-    error(msg) {
-        console.error(`[${ts()}] [ERROR] ${msg}`);
-    },
+  /**
+   * Logs an informational message with timestamp and [INFO] prefix.
+   * Used for progress updates, build completion, server startup, etc.
+   *
+   * @param msg Message to log
+   *
+   * @example log.info("Server running on port 3000");
+   */
+  info(msg) {
+    console.log(
+      `${colors.dim}[${ts()}]${colors.reset} ${colors.cyan}[INFO]${colors.reset} ${msg}`,
+    );
+  },
+  /**
+   * Logs a warning message with timestamp and [WARN] prefix.
+   * Used for non-fatal issues, deprecated usage, or recoverable problems.
+   *
+   * @param msg Warning message to log
+   *
+   * @example log.warn("Configuration file not found, using defaults");
+   */
+  warn(msg) {
+    console.warn(
+      `${colors.dim}[${ts()}]${colors.reset} ${colors.yellow}[WARN]${colors.reset} ${msg}`,
+    );
+  },
+  /**
+   * Logs an error message with timestamp and [ERROR] prefix.
+   * Used for critical failures that require immediate attention.
+   *
+   * @param msg Error message to log
+   *
+   * @example log.error("Failed to compile SCSS: syntax error on line 42");
+   */
+  error(msg) {
+    console.error(
+      `${colors.dim}[${ts()}]${colors.reset} ${colors.red}[ERROR]${colors.reset} ${msg}`,
+    );
+  },
 };

package/templates/static/lib/telemetry/api/rate-limiter.js

@@ -0,0 +1,32 @@
+/**
+ * Rate limiter for telemetry API
+ * Limits requests per IP address
+ */
+class RateLimiter {
+  store = new Map();
+  limit = 10;
+  windowMs = 60 * 1000; // 60 seconds
+  check(ip) {
+    const now = Date.now();
+    const entry = this.store.get(ip);
+    // Reset if window has expired
+    if (!entry || now > entry.resetTime) {
+      this.store.set(ip, {
+        count: 1,
+        resetTime: now + this.windowMs,
+      });
+      return true;
+    }
+    // Check if limit exceeded
+    if (entry.count >= this.limit) {
+      return false;
+    }
+    // Increment and allow
+    entry.count++;
+    return true;
+  }
+  reset() {
+    this.store.clear();
+  }
+}
+export const rateLimiter = new RateLimiter();

package/templates/static/lib/telemetry/api/validator.js

@@ -0,0 +1,67 @@
+/**
+ * Telemetry payload validator
+ */
+const MAX_STRING_LENGTH = 50;
+const MAX_EVENTS = 100;
+export function validatePayload(payload) {
+  // Handle array of events
+  if (Array.isArray(payload)) {
+    if (payload.length === 0) {
+      return { valid: false, error: "Event array cannot be empty" };
+    }
+    if (payload.length > MAX_EVENTS) {
+      return {
+        valid: false,
+        error: `Too many events (max ${MAX_EVENTS})`,
+      };
+    }
+    // Validate each event
+    for (const event of payload) {
+      const result = validateEvent(event);
+      if (!result.valid) {
+        return result;
+      }
+    }
+    return { valid: true };
+  }
+  // Handle single event
+  return validateEvent(payload);
+}
+function validateEvent(event) {
+  if (typeof event !== "object" || event === null) {
+    return { valid: false, error: "Event must be an object" };
+  }
+  const obj = event;
+  // Required fields
+  if (typeof obj.framework !== "string") {
+    return { valid: false, error: "Missing or invalid framework field" };
+  }
+  if (typeof obj.version !== "string") {
+    return { valid: false, error: "Missing or invalid version field" };
+  }
+  // Validate string lengths
+  if (obj.framework.length > MAX_STRING_LENGTH) {
+    return {
+      valid: false,
+      error: `framework exceeds max length of ${MAX_STRING_LENGTH}`,
+    };
+  }
+  if (obj.version.length > MAX_STRING_LENGTH) {
+    return {
+      valid: false,
+      error: `version exceeds max length of ${MAX_STRING_LENGTH}`,
+    };
+  }
+  // Optional string fields
+  for (const field of ["command", "os", "error"]) {
+    if (field in obj && typeof obj[field] === "string") {
+      if (obj[field].length > MAX_STRING_LENGTH) {
+        return {
+          valid: false,
+          error: `${field} exceeds max length of ${MAX_STRING_LENGTH}`,
+        };
+      }
+    }
+  }
+  return { valid: true };
+}

package/templates/static/lib/telemetry/client.js

@@ -0,0 +1,121 @@
+/**
+ * Jen.js Telemetry Client
+ *
+ * Collects telemetry events and sends them in batches.
+ * Usage:
+ *   telemetry.track({ command: 'dev', os: 'win32' });
+ *   // Events are sent automatically every 15 seconds or when batch is full
+ */
+import { platform } from "os";
+class TelemetryClient {
+  endpoint;
+  batchSize;
+  batchInterval;
+  disabled;
+  queue = [];
+  flushTimer = null;
+  version;
+  constructor(version, options = {}) {
+    this.version = version;
+    this.endpoint =
+      options.endpoint || "https://telemetry-six.vercel.app/telemetry";
+    this.batchSize = options.batchSize || 50;
+    this.batchInterval = options.batchInterval || 15 * 1000; // 15 seconds
+    this.disabled = options.disabled || process.env.TELEMETRY_DISABLED === "1";
+  }
+  track(event) {
+    if (this.disabled) {
+      return;
+    }
+    const telemetryEvent = {
+      framework: "jenjs",
+      version: this.version,
+      os: platform(),
+      ...event,
+    };
+    this.queue.push(telemetryEvent);
+    // Flush immediately if batch is full
+    if (this.queue.length >= this.batchSize) {
+      this.flush();
+      return;
+    }
+    // Schedule flush if not already scheduled
+    if (!this.flushTimer) {
+      this.flushTimer = setTimeout(() => this.flush(), this.batchInterval);
+    }
+  }
+  async flush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.queue.length === 0) {
+      return;
+    }
+    const events = this.queue;
+    this.queue = [];
+    try {
+      await this.send(events);
+    } catch (error) {
+      if (process.env.DEBUG_TELEMETRY) {
+        console.error("Telemetry send failed:", error);
+      }
+      // Silently fail - telemetry is fire-and-forget
+    }
+  }
+  async send(events) {
+    // Try using fetch if available (Node 18+)
+    if (typeof fetch !== "undefined") {
+      const response = await fetch(this.endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(events),
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      return;
+    }
+    // Fallback to https module for older Node versions
+    await this.sendWithHttps(events);
+  }
+  async sendWithHttps(events) {
+    const https = await import("https");
+    const url = new URL(this.endpoint);
+    const body = JSON.stringify(events);
+    return new Promise((resolve, reject) => {
+      const options = {
+        hostname: url.hostname,
+        port: url.port,
+        path: url.pathname,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(body),
+        },
+      };
+      const req = https.request(options, (res) => {
+        if (res.statusCode !== 200) {
+          reject(new Error(`HTTP ${res.statusCode}`));
+        } else {
+          resolve();
+        }
+        res.on("data", () => {});
+      });
+      req.on("error", reject);
+      req.write(body);
+      req.end();
+    });
+  }
+  disable() {
+    this.disabled = true;
+    this.queue = [];
+  }
+  enable() {
+    this.disabled = false;
+  }
+}
+// Export factory function
+export function createTelemetry(version, options) {
+  return new TelemetryClient(version, options);
+}

package/templates/static/lib/telemetry/tests/rate-limiter.test.js

@@ -0,0 +1,46 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { rateLimiter } from "../api/rate-limiter.js";
+describe("Rate Limiter", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+  it("should allow requests within limit", () => {
+    const ip = "192.168.1.1";
+    for (let i = 0; i < 10; i++) {
+      expect(rateLimiter.check(ip)).toBe(true);
+    }
+  });
+  it("should block requests exceeding limit", () => {
+    const ip = "192.168.1.2";
+    // First 10 allowed
+    for (let i = 0; i < 10; i++) {
+      expect(rateLimiter.check(ip)).toBe(true);
+    }
+    // 11th blocked
+    expect(rateLimiter.check(ip)).toBe(false);
+  });
+  it("should allow different IPs independently", () => {
+    const ip1 = "192.168.1.100";
+    const ip2 = "192.168.1.101";
+    for (let i = 0; i < 10; i++) {
+      expect(rateLimiter.check(ip1)).toBe(true);
+      expect(rateLimiter.check(ip2)).toBe(true);
+    }
+    expect(rateLimiter.check(ip1)).toBe(false);
+    expect(rateLimiter.check(ip2)).toBe(false);
+  });
+  it("should reset limits after window expires", () => {
+    vi.useFakeTimers();
+    const ip = "192.168.1.200";
+    // Fill limit
+    for (let i = 0; i < 10; i++) {
+      expect(rateLimiter.check(ip)).toBe(true);
+    }
+    expect(rateLimiter.check(ip)).toBe(false);
+    // Advance time past window
+    vi.advanceTimersByTime(61 * 1000); // 61 seconds
+    // Should allow again
+    expect(rateLimiter.check(ip)).toBe(true);
+    vi.useRealTimers();
+  });
+});