create-jen-app 1.2.2 → 1.2.4

package/templates/static/lib/compilers/vue.js

@@ -1,99 +1,90 @@
-/*
- * 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 { parse, compileScript, compileTemplate, compileStyle } from "@vue/compiler-sfc";
+import {
+  parse,
+  compileScript,
+  compileTemplate,
+  compileStyle,
+} from "@vue/compiler-sfc";
 import { log } from "../shared/log.js";
 export class VueCompiler {
-    compile(source, options) {
-        try {
-            const filename = options.filename || "component.vue";
-            const id = options.id || filename.replace(/[^a-z0-9]/gi, "_");
-            // Parse SFC
-            const parseResult = parse(source, { filename });
-            const descriptor = parseResult.descriptor;
-            let scriptCode = "";
-            let templateCode = "";
-            let styleCode = "";
-            // Compile script
-            if (descriptor.script || descriptor.scriptSetup) {
-                const scriptCompiled = compileScript(descriptor, {
-                    id,
-                    isProd: options.minified ?? false,
-                });
-                scriptCode = scriptCompiled.content;
-            }
-            // Compile template
-            if (descriptor.template) {
-                const templateCompiled = compileTemplate({
-                    source: descriptor.template.content,
-                    filename,
-                    id,
-                    compilerOptions: {
-                        isCustomElement: (tag) => tag.startsWith("custom-"),
-                    },
-                });
-                if (templateCompiled.errors.length > 0) {
-                    return {
-                        code: "",
-                        error: `Template compilation error: ${templateCompiled.errors.join(", ")}`,
-                    };
-                }
-                templateCode = templateCompiled.code;
-            }
-            // Compile styles (scoped)
-            if (descriptor.styles.length > 0) {
-                descriptor.styles.forEach((style, idx) => {
-                    const styleCompiled = compileStyle({
-                        source: style.content,
-                        filename,
-                        id,
-                        scoped: style.scoped ?? false,
-                    });
-                    if (styleCompiled.errors.length > 0) {
-                        log.warn(`Style compilation warning at style[${idx}]: ${styleCompiled.errors.join(", ")}`);
-                    }
-                    styleCode += styleCompiled.code + "\n";
-                });
-            }
-            // Inject styles at runtime
-            let injectStyle = "";
-            if (styleCode.trim()) {
-                const escapedStyle = styleCode.replace(/"/g, '\\"').replace(/\n/g, "\\n");
-                injectStyle = `
+  compile(source, options) {
+    try {
+      const filename = options.filename || "component.vue";
+      const id = options.id || filename.replace(/[^a-z0-9]/gi, "_");
+      // Parse SFC
+      const parseResult = parse(source, { filename });
+      const descriptor = parseResult.descriptor;
+      let scriptCode = "";
+      let templateCode = "";
+      let styleCode = "";
+      // Compile script
+      if (descriptor.script || descriptor.scriptSetup) {
+        const scriptCompiled = compileScript(descriptor, {
+          id,
+          isProd: options.minified ?? false,
+        });
+        scriptCode = scriptCompiled.content;
+      }
+      // Compile template
+      if (descriptor.template) {
+        const templateCompiled = compileTemplate({
+          source: descriptor.template.content,
+          filename,
+          id,
+          compilerOptions: {
+            isCustomElement: (tag) => tag.startsWith("custom-"),
+          },
+        });
+        if (templateCompiled.errors.length > 0) {
+          return {
+            code: "",
+            error: `Template compilation error: ${templateCompiled.errors.join(", ")}`,
+          };
+        }
+        templateCode = templateCompiled.code;
+      }
+      // Compile styles (scoped)
+      if (descriptor.styles.length > 0) {
+        descriptor.styles.forEach((style, idx) => {
+          const styleCompiled = compileStyle({
+            source: style.content,
+            filename,
+            id,
+            scoped: style.scoped ?? false,
+          });
+          if (styleCompiled.errors.length > 0) {
+            log.warn(
+              `Style compilation warning at style[${idx}]: ${styleCompiled.errors.join(", ")}`,
+            );
+          }
+          styleCode += styleCompiled.code + "\n";
+        });
+      }
+      // Inject styles at runtime
+      let injectStyle = "";
+      if (styleCode.trim()) {
+        const escapedStyle = styleCode
+          .replace(/"/g, '\\"')
+          .replace(/\n/g, "\\n");
+        injectStyle = `
 const style = document.createElement('style');
 style.textContent = "${escapedStyle}";
 document.head.appendChild(style);
 `;
-            }
-            // Build final module
-            const finalCode = `
+      }
+      // Build final module
+      const finalCode = `
 ${scriptCode || "export default {}"}
 ${templateCode}
 ${injectStyle}
 `;
-            return { code: finalCode };
-        }
-        catch (err) {
-            const message = err.message || String(err);
-            log.error(`[Vue] Compilation error: ${message}`);
-            return { code: "", error: message };
-        }
+      return { code: finalCode };
+    } catch (err) {
+      const message = err.message || String(err);
+      log.error(`[Vue] Compilation error: ${message}`);
+      return { code: "", error: message };
     }
+  }
 }
 export function createVueCompiler() {
-    return new VueCompiler();
+  return new VueCompiler();
 }

package/templates/static/lib/core/config.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/core/feature-guard.js

@@ -0,0 +1,136 @@
+import { isFeatureEnabled } from "./features.js";
+/**
+ * Feature guard errors provide helpful context when code tries to use disabled features.
+ * Includes the feature name and guidance on how to enable it.
+ */
+export class FeatureDisabledError extends Error {
+  feature;
+  constructor(feature, context) {
+    const msg =
+      `Feature "${feature}" is not enabled. ` +
+      `Enable it in jen.config.ts with: features: { ${feature}: true }${context ? ` (${context})` : ""}`;
+    super(msg);
+    this.feature = feature;
+    this.name = "FeatureDisabledError";
+  }
+}
+/**
+ * Feature configuration errors indicate invalid feature configuration.
+ */
+export class FeatureConfigError extends Error {
+  feature;
+  constructor(feature, details) {
+    super(`Invalid configuration for feature "${feature}": ${details}`);
+    this.feature = feature;
+    this.name = "FeatureConfigError";
+  }
+}
+/**
+ * Validates that a feature is enabled before execution.
+ * Throws helpful error if feature is disabled.
+ *
+ * Use in feature module entry points to prevent disabled features from running.
+ *
+ * @param features Resolved feature configuration
+ * @param feature Feature name to validate
+ * @param context Optional context (e.g., function name) for error message
+ * @throws FeatureDisabledError if feature is not enabled
+ *
+ * @example
+ * export function setupApiRoutes(features: ResolvedFeatures) {
+ *   guardFeature(features, "api", "API route handling");
+ *   // ... API setup code
+ * }
+ */
+export function guardFeature(features, feature, context) {
+  if (!isFeatureEnabled(features, feature)) {
+    throw new FeatureDisabledError(feature, context);
+  }
+}
+/**
+ * Guards multiple features, throwing if any are disabled.
+ * Useful for features that depend on other features.
+ *
+ * @example
+ * export function setupAdvancedMiddleware(features: ResolvedFeatures) {
+ *   guardFeatures(features, ["middleware", "cache"], "Advanced middleware");
+ *   // ... code that uses both features
+ * }
+ */
+export function guardFeatures(features, required, context) {
+  const missing = required.filter((f) => !isFeatureEnabled(features, f));
+  if (missing.length > 0) {
+    const list = missing.join(", ");
+    throw new Error(
+      `Features required: ${list}. ` +
+        `Enable them in jen.config.ts${context ? ` (${context})` : ""}`,
+    );
+  }
+}
+/**
+ * Type guard that narrows feature type based on enabled status.
+ * Allows TypeScript to enforce feature availability at compile time.
+ *
+ * @example
+ * if (isFeatureAvailable(features, "api")) {
+ *   // TypeScript knows "api" is enabled here
+ *   const result = handleApiRequest(...);
+ * }
+ */
+export function isFeatureAvailable(features, feature) {
+  return isFeatureEnabled(features, feature);
+}
+/**
+ * Wraps a function to guard against disabled features.
+ * Returns a function that checks feature before execution.
+ *
+ * @example
+ * export const setupCache = guardedFunction("cache", (features) => {
+ *   // This only runs if cache feature is enabled
+ * });
+ */
+export function guardedFunction(feature, fn, context) {
+  return (...args) => {
+    const features = args[0];
+    guardFeature(features, feature, context);
+    return fn(...args);
+  };
+}
+/**
+ * Async version of guardedFunction for async handlers.
+ */
+export function guardedAsyncFunction(feature, fn, context) {
+  return async (...args) => {
+    const features = args[0];
+    guardFeature(features, feature, context);
+    return fn(...args);
+  };
+}
+/**
+ * Creates a feature validation middleware.
+ * Checks if required feature is enabled before processing request.
+ *
+ * @example
+ * app.use(featureMiddleware("api", (ctx, next) => {
+ *   // Only runs if api feature is enabled
+ *   return handleApiRequest(ctx);
+ * }));
+ */
+export function createFeatureMiddleware(feature, context) {
+  return (features) => {
+    guardFeature(features, feature, context);
+  };
+}
+/**
+ * Validates feature configuration against a schema.
+ */
+export function validateFeatureConfig(feature, config, validator) {
+  if (!validator) return;
+  const result = validator.validate(config);
+  if (!result.valid) {
+    throw new FeatureConfigError(
+      feature,
+      result.errors?.join("; ") || "Invalid configuration",
+    );
+  }
+}

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

@@ -0,0 +1,99 @@
+/**
+ * Feature System for Jen.js
+ *
+ * Allows optional features to be enabled/disabled at build time.
+ * Disabled features are completely tree-shaken, adding zero runtime overhead.
+ *
+ * Features are configured in jen.config.ts and enabled/disabled individually.
+ * Each feature must be explicitly enabled for its code to be included in the bundle.
+ */
+/**
+ * Default features enabled when none specified.
+ * Minimal set to maintain backward compatibility.
+ * Users should explicitly enable features they use.
+ */
+export const DEFAULT_FEATURES = {
+  api: false,
+  middleware: false,
+  markdown: false,
+  imageOpt: false,
+  env: true, // Environment variables needed by default
+  cache: false,
+  streaming: false,
+  auth: false,
+  graphql: false,
+  db: false,
+  i18n: false,
+  jdb: false,
+  compilers: false,
+  import: false,
+};
+/**
+ * Validates and normalizes user feature configuration.
+ * Ensures all features have explicit enabled/disabled status.
+ *
+ * @param userConfig User-provided feature config from jen.config.ts
+ * @returns Resolved features with all present and validated
+ */
+export function resolveFeatures(userConfig) {
+  const resolved = { ...DEFAULT_FEATURES };
+  if (!userConfig) return resolved;
+  for (const [key, value] of Object.entries(userConfig)) {
+    if (!(key in DEFAULT_FEATURES)) {
+      console.warn(
+        `⚠️  Unknown feature: "${key}". Valid features are: ${Object.keys(DEFAULT_FEATURES).join(", ")}`,
+      );
+      continue;
+    }
+    // Support boolean shorthand and object with enabled property
+    const isEnabled =
+      typeof value === "boolean" ? value : value?.enabled !== false;
+    resolved[key] = isEnabled;
+  }
+  return resolved;
+}
+/**
+ * Returns list of enabled feature names.
+ */
+export function getEnabledFeatures(resolved) {
+  return Object.entries(resolved)
+    .filter(([, enabled]) => enabled)
+    .map(([name]) => name);
+}
+/**
+ * Returns list of disabled feature names.
+ */
+export function getDisabledFeatures(resolved) {
+  return Object.entries(resolved)
+    .filter(([, enabled]) => !enabled)
+    .map(([name]) => name);
+}
+/**
+ * Checks if a specific feature is enabled.
+ */
+export function isFeatureEnabled(resolved, feature) {
+  return resolved[feature] ?? false;
+}
+/**
+ * Runtime assertion that a feature is enabled.
+ * Throws helpful error if feature is disabled.
+ */
+export function requireFeature(resolved, feature, context) {
+  if (!isFeatureEnabled(resolved, feature)) {
+    const msg =
+      `Feature "${feature}" is not enabled. ` +
+      `Enable it in jen.config.ts: features: { ${feature}: true }${context ? ` (${context})` : ""}`;
+    throw new Error(msg);
+  }
+}
+/**
+ * Creates build metadata for introspection and debugging.
+ */
+export function createBuildMetadata(resolved, config) {
+  return {
+    buildTime: new Date().toISOString(),
+    enabledFeatures: getEnabledFeatures(resolved),
+    disabledFeatures: getDisabledFeatures(resolved),
+    config,
+  };
+}

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

@@ -1,42 +1,71 @@
-/*
- * 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/>.
+/**
+ * Parses the HTTP Cookie header into an object of name-value pairs.
+ *
+ * Cookie format (RFC 6265):
+ * - Multiple cookies separated by semicolons
+ * - Each cookie is name=value with optional whitespace
+ * - Cookie values are URL-encoded and must be decoded
+ *
+ * Edge cases handled:
+ * - Missing or empty Cookie header returns empty object
+ * - Whitespace is trimmed from names and values
+ * - Values may contain equals signs (split only on first =)
+ * - Empty names or values are filtered out
+ * - Values are URL-decoded to handle special characters
+ *
+ * @param req Node.js IncomingMessage with headers property
+ *
+ * @returns Object with cookie names as keys and decoded values
+ *
+ * @example
+ * // Header: "sessionId=abc123; theme=dark; path=/admin"
+ * // Returns: { sessionId: "abc123", theme: "dark", path: "/admin" }
+ *
+ * // Header missing or empty
+ * // Returns: {}
  */
 export function parseCookies(req) {
-    const cookie = req.headers.cookie;
-    if (!cookie)
-        return {};
-    const out = {};
-    for (const part of cookie.split(";")) {
-        const [k, ...rest] = part.trim().split("=");
-        const trimmedName = k.trim();
-        const trimmedValue = rest.join("=").trim();
-        if (trimmedName && trimmedValue) {
-            out[trimmedName] = decodeURIComponent(trimmedValue);
-        }
+  const cookie = req.headers.cookie;
+  if (!cookie) return {};
+  const out = {};
+  for (const part of cookie.split(";")) {
+    const [k, ...rest] = part.trim().split("=");
+    const trimmedName = k.trim();
+    const trimmedValue = rest.join("=").trim();
+    if (trimmedName && trimmedValue) {
+      out[trimmedName] = decodeURIComponent(trimmedValue);
     }
-    return out;
+  }
+  return out;
 }
+/**
+ * Converts Node.js headers object to a flat string-valued object.
+ *
+ * Header normalization:
+ * - Node.js headers may have array values (for multiple headers with same name)
+ * - Arrays are joined with comma-space to follow HTTP spec (RFC 2822)
+ * - Non-array string values are kept as-is
+ * - Header names are already lowercased by Node.js
+ *
+ * Motivation:
+ * Application code typically expects headers as a flat object with string values,
+ * not Node.js's mixed types. This normalizes the data structure for consistency.
+ *
+ * @param headers The headers object from IncomingMessage.headers
+ *
+ * @returns Flat object with header names (lowercase) as keys and string values
+ *
+ * @example
+ * // Input (from Node.js):
+ * { accept: "text/html", "accept-encoding": ["gzip", "deflate"], "content-type": "application/json" }
+ * // Output:
+ * { accept: "text/html", "accept-encoding": "gzip, deflate", "content-type": "application/json" }
+ */
 export function headersToObject(headers) {
-    const out = {};
-    for (const [k, v] of Object.entries(headers)) {
-        if (Array.isArray(v))
-            out[k] = v.join(", ");
-        else if (typeof v === "string")
-            out[k] = v;
-    }
-    return out;
+  const out = {};
+  for (const [k, v] of Object.entries(headers)) {
+    if (Array.isArray(v)) out[k] = v.join(", ");
+    else if (typeof v === "string") out[k] = v;
+  }
+  return out;
 }

package/templates/static/lib/core/layouts/index.js

@@ -0,0 +1,10 @@
+/**
+ * Nested layouts system for Jen.js
+ * Provides automatic parent-child layout relationships with inheritance and overrides.
+ */
+export { scanLayouts, buildLayoutHierarchy } from "./scan.js";
+export {
+  resolveLayoutStack,
+  renderWithLayoutStack,
+  collectLayoutHeads,
+} from "./render.js";