create-jen-app 1.2.3 → 1.2.4

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

@@ -0,0 +1,180 @@
+import { log } from "../shared/log.js";
+/**
+ * Creates a ServerActionContext from request/response objects.
+ * Handles body parsing, header extraction, and cookie parsing.
+ */
+export async function createServerActionContext(opts) {
+  const { req, res, url, params = {}, headers, cookies } = opts;
+  // Parse request body based on content type
+  const body = await parseRequestBody(req);
+  // Extract method
+  const method = (req.method ?? "GET").toUpperCase();
+  // Extract query parameters
+  const query = {};
+  for (const [k, v] of url.searchParams.entries()) {
+    query[k] = v;
+  }
+  return {
+    req,
+    res,
+    url,
+    method,
+    body,
+    query,
+    params,
+    headers,
+    cookies,
+    data: {},
+    validate(input, schema) {
+      const errors = {};
+      let success = true;
+      for (const [fieldName, rules] of Object.entries(schema)) {
+        const value = input[fieldName];
+        for (const rule of rules) {
+          const error = rule.validate(value);
+          if (error) {
+            errors[fieldName] = error;
+            success = false;
+            break; // Stop at first error for this field
+          }
+        }
+      }
+      return { success, errors };
+    },
+    stream() {
+      // Set headers for streaming response
+      if (!res.headersSent) {
+        res.statusCode = 200;
+        res.setHeader("content-type", "application/x-ndjson; charset=utf-8");
+        res.setHeader("transfer-encoding", "chunked");
+      }
+      return {
+        write(data) {
+          const line = typeof data === "string" ? data : JSON.stringify(data);
+          res.write(line + "\n");
+        },
+        writeJSON(data) {
+          res.write(JSON.stringify(data) + "\n");
+        },
+        close() {
+          if (!res.writableEnded) {
+            res.end();
+          }
+        },
+      };
+    },
+  };
+}
+/**
+ * Parse request body from IncomingMessage.
+ * Handles JSON and form data content types.
+ */
+async function parseRequestBody(req) {
+  const method = (req.method ?? "GET").toUpperCase();
+  // Methods without bodies per HTTP spec
+  if (method === "GET" || method === "HEAD") {
+    return null;
+  }
+  // Read all body chunks
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.from(chunk));
+  }
+  if (chunks.length === 0) {
+    return null;
+  }
+  const raw = Buffer.concat(chunks).toString("utf8");
+  const contentType = (req.headers["content-type"] ?? "").toString();
+  // Parse JSON
+  if (contentType.includes("application/json")) {
+    try {
+      return JSON.parse(raw);
+    } catch (err) {
+      log.warn(`Failed to parse JSON body: ${err}`);
+      return { __raw: raw };
+    }
+  }
+  // Parse form data
+  if (contentType.includes("application/x-www-form-urlencoded")) {
+    const data = {};
+    const params = new URLSearchParams(raw);
+    for (const [k, v] of params.entries()) {
+      data[k] = v;
+    }
+    return data;
+  }
+  // Parse multipart form data (basic support)
+  if (contentType.includes("multipart/form-data")) {
+    // For now, return raw. Full multipart parsing requires a library
+    return { __raw: raw };
+  }
+  // Default: return as raw
+  return { __raw: raw };
+}
+/**
+ * Execute a server action handler with the given context.
+ * Handles validation, error handling, and response serialization.
+ */
+export async function executeServerAction(opts) {
+  const { handler, ctx, validation } = opts;
+  try {
+    // Run validation if schema provided
+    if (validation) {
+      const validationResult = ctx.validate(ctx.body, validation);
+      if (!validationResult.success) {
+        ctx.res.statusCode = 400;
+        ctx.res.setHeader("content-type", "application/json; charset=utf-8");
+        ctx.res.end(
+          JSON.stringify({
+            success: false,
+            errors: validationResult.errors,
+            message: "Validation failed",
+          }),
+        );
+        return;
+      }
+    }
+    // Execute the handler
+    const result = await handler(ctx);
+    // If response already sent (streaming), don't double-send
+    if (ctx.res.writableEnded) {
+      return;
+    }
+    // Handle Response object
+    if (result instanceof Response) {
+      ctx.res.statusCode = result.status;
+      result.headers.forEach((v, k) => ctx.res.setHeader(k, v));
+      const buf = Buffer.from(await result.arrayBuffer());
+      ctx.res.end(buf);
+      return;
+    }
+    // Serialize as JSON
+    ctx.res.statusCode = 200;
+    ctx.res.setHeader("content-type", "application/json; charset=utf-8");
+    if (result === null || result === undefined) {
+      ctx.res.end(JSON.stringify({ success: true, data: null }));
+    } else if (typeof result === "string") {
+      ctx.res.end(JSON.stringify({ success: true, data: result }));
+    } else {
+      ctx.res.end(JSON.stringify({ success: true, ...result }));
+    }
+  } catch (err) {
+    // Error response
+    log.error(`Server action error: ${err.message}`);
+    if (!ctx.res.headersSent) {
+      ctx.res.statusCode = 500;
+      ctx.res.setHeader("content-type", "application/json; charset=utf-8");
+    }
+    if (!ctx.res.writableEnded) {
+      ctx.res.end(
+        JSON.stringify({
+          success: false,
+          message: "Internal server error",
+          ...(process.env.NODE_ENV === "development" && {
+            error: err.message,
+          }),
+        }),
+      );
+    }
+  }
+}

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

@@ -0,0 +1,19 @@
+// Validators
+export {
+  required,
+  minLength,
+  maxLength,
+  email,
+  url,
+  pattern,
+  range,
+  custom,
+  enumValue,
+  type,
+} from "./validators.js";
+// Scanning and routing
+export { scanServerActions, matchServerAction } from "./scan.js";
+// Handler and context creation
+export { createServerActionContext, executeServerAction } from "./handler.js";
+// Middleware factory
+export { createServerActionsMiddleware } from "./middleware.js";

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

@@ -0,0 +1,146 @@
+import { pathToFileURL } from "node:url";
+import esbuild from "esbuild";
+import { basename, join } from "node:path";
+import { log } from "../shared/log.js";
+import { headersToObject, parseCookies } from "../core/http.js";
+import { scanServerActions, matchServerAction } from "./scan.js";
+import { createServerActionContext, executeServerAction } from "./handler.js";
+/** Cache directory for transpiled server actions. */
+const actionsCacheDir = join(
+  process.cwd(),
+  "node_modules",
+  ".jen",
+  "actions-cache",
+);
+/**
+ * Transpile a TypeScript server action file to JavaScript.
+ * Uses esbuild to convert TS → JS and output as ESM.
+ */
+async function transpileServerAction(filePath) {
+  const outfile = join(
+    actionsCacheDir,
+    basename(filePath).replace(/\.ts$/, `.${Date.now()}.mjs`),
+  );
+  await esbuild.build({
+    entryPoints: [filePath],
+    outfile,
+    format: "esm",
+    platform: "node",
+    target: "es2022",
+    bundle: false,
+    external: ["preact", "preact-render-to-string", "jenjs"],
+    write: true,
+  });
+  return outfile;
+}
+/**
+ * Load a server action module and extract its configuration and handler.
+ */
+async function loadServerActionModule(filePath) {
+  let moduleUrl = filePath;
+  // Transpile TypeScript to JavaScript if needed
+  if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) {
+    moduleUrl = await transpileServerAction(filePath);
+  }
+  try {
+    // Cache-busting query param for dev mode
+    const mod = await import(
+      pathToFileURL(moduleUrl).href + `?t=${Date.now()}`
+    );
+    return mod.default ? { default: mod.default, ...mod } : mod;
+  } catch (err) {
+    log.error(`Failed to load server action: ${err.message}`);
+    throw new Error(`Failed to load server action module: ${err.message}`);
+  }
+}
+/**
+ * Create a middleware that handles server actions.
+ * Scans the actions directory and routes requests to action handlers.
+ *
+ * Routes server action requests to /actions/* endpoints and executes them
+ * with validation, error handling, and streaming support.
+ */
+export async function createServerActionsMiddleware(opts) {
+  const { config } = opts;
+  // Scan actions directory once at startup
+  const actions = scanServerActions(config);
+  log.info(`Server actions discovered: ${actions.length}`);
+  for (const a of actions) {
+    log.info(`  ${a.actionPath} (${a.name})`);
+  }
+  // Cache loaded action modules
+  const moduleCache = new Map();
+  return async (ctx, next) => {
+    // Only handle /actions/* requests
+    if (!ctx.url.pathname.startsWith("/actions/")) {
+      return next();
+    }
+    // Extract action path (remove /actions prefix)
+    const actionPath = ctx.url.pathname.slice("/actions".length);
+    // Match against discovered actions
+    const match = matchServerAction(actions, actionPath);
+    if (!match) {
+      ctx.res.statusCode = 404;
+      ctx.res.setHeader("content-type", "application/json; charset=utf-8");
+      ctx.res.end(
+        JSON.stringify({ success: false, message: "Action not found" }),
+      );
+      return;
+    }
+    const { action, params } = match;
+    try {
+      // Load action module (use cache to avoid reloading)
+      let actionModule = moduleCache.get(action.id);
+      if (!actionModule) {
+        actionModule = await loadServerActionModule(action.filePath);
+        moduleCache.set(action.id, actionModule);
+      }
+      // Extract configuration
+      const metadata = actionModule.metadata || {};
+      const validation = actionModule.validation;
+      const handler = actionModule.default;
+      if (!handler || typeof handler !== "function") {
+        ctx.res.statusCode = 500;
+        ctx.res.setHeader("content-type", "application/json; charset=utf-8");
+        ctx.res.end(
+          JSON.stringify({
+            success: false,
+            message: "Invalid action: no handler exported",
+          }),
+        );
+        return;
+      }
+      // Create action context
+      const reqHeaders = headersToObject(ctx.req.headers);
+      const cookies = parseCookies(ctx.req);
+      const actionCtx = await createServerActionContext({
+        req: ctx.req,
+        res: ctx.res,
+        url: ctx.url,
+        params,
+        headers: reqHeaders,
+        cookies,
+      });
+      // Execute server action
+      await executeServerAction({
+        handler,
+        ctx: actionCtx,
+        validation,
+      });
+    } catch (err) {
+      log.error(`Server action error: ${err.message}`);
+      if (!ctx.res.headersSent) {
+        ctx.res.statusCode = 500;
+        ctx.res.setHeader("content-type", "application/json; charset=utf-8");
+      }
+      if (!ctx.res.writableEnded) {
+        ctx.res.end(
+          JSON.stringify({
+            success: false,
+            message: "Internal server error",
+          }),
+        );
+      }
+    }
+  };
+}

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;
+    },
+  };
+}