create-jen-app 1.2.2 → 1.2.4

package/templates/static/lib/middleware/response.js

@@ -1,60 +1,107 @@
-/*
- * This file is part of Jen.js.
- * Copyright (C) 2026 oopsio
+/**
+ * Fluent builder for constructing HTTP responses.
+ * Provides a chainable API for setting status codes, headers, body, and content type.
+ * Delegates actual response sending to the underlying Node.js ServerResponse.
  *
- * 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 builder is used in the Context to provide convenient response composition
+ * without manually managing headers and response state.
  *
- * 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/>.
+ * @example
+ * ctx.response
+ *   .status(201)
+ *   .header('X-Custom', 'value')
+ *   .json({ id: 123, name: 'Alice' })
+ *   .send();
  */
 export class ResponseBuilder {
-    statusCode = 200;
-    headers = {};
-    body = null;
-    res;
-    constructor(res) {
-        this.res = res;
-    }
-    status(code) {
-        this.statusCode = code;
-        return this;
-    }
-    header(key, value) {
-        this.headers[key] = value;
-        return this;
-    }
-    json(data) {
-        this.header("Content-Type", "application/json");
-        this.body = JSON.stringify(data);
-        return this;
-    }
-    html(html) {
-        this.header("Content-Type", "text/html");
-        this.body = html;
-        return this;
-    }
-    text(text) {
-        this.header("Content-Type", "text/plain");
-        this.body = text;
-        return this;
-    }
-    send() {
-        if (this.res.writableEnded)
-            return;
-        this.res.writeHead(this.statusCode, this.headers);
-        if (this.body !== null && this.body !== undefined) {
-            this.res.end(this.body);
-        }
-        else {
-            this.res.end();
-        }
+  // HTTP status code to send (default 200 OK).
+  statusCode = 200;
+  // Header key-value pairs to include in the response.
+  headers = {};
+  // Response body content (string, Buffer, or null for empty body).
+  body = null;
+  // The underlying Node.js ServerResponse object.
+  res;
+  /**
+   * Initializes a ResponseBuilder with the given ServerResponse.
+   *
+   * @param res The Node.js ServerResponse object to write to.
+   */
+  constructor(res) {
+    this.res = res;
+  }
+  /**
+   * Sets the HTTP status code for the response.
+   *
+   * @param code The HTTP status code (e.g., 200, 404, 500).
+   * @returns This ResponseBuilder instance for method chaining.
+   */
+  status(code) {
+    this.statusCode = code;
+    return this;
+  }
+  /**
+   * Adds an HTTP response header.
+   * Multiple calls with the same key overwrite previous values.
+   *
+   * @param key The header name.
+   * @param value The header value.
+   * @returns This ResponseBuilder instance for method chaining.
+   */
+  header(key, value) {
+    this.headers[key] = value;
+    return this;
+  }
+  /**
+   * Sets the response body to a JSON-serialized object and sets Content-Type header.
+   * Automatically sets Content-Type to application/json.
+   *
+   * @param data The object to serialize as JSON.
+   * @returns This ResponseBuilder instance for method chaining.
+   */
+  json(data) {
+    this.header("Content-Type", "application/json");
+    this.body = JSON.stringify(data);
+    return this;
+  }
+  /**
+   * Sets the response body to HTML content and sets Content-Type header.
+   * Automatically sets Content-Type to text/html.
+   *
+   * @param html The HTML string to send.
+   * @returns This ResponseBuilder instance for method chaining.
+   */
+  html(html) {
+    this.header("Content-Type", "text/html");
+    this.body = html;
+    return this;
+  }
+  /**
+   * Sets the response body to plain text and sets Content-Type header.
+   * Automatically sets Content-Type to text/plain.
+   *
+   * @param text The plain text string to send.
+   * @returns This ResponseBuilder instance for method chaining.
+   */
+  text(text) {
+    this.header("Content-Type", "text/plain");
+    this.body = text;
+    return this;
+  }
+  /**
+   * Sends the response to the client.
+   * Writes the status code, headers, and body to the underlying ServerResponse.
+   * Does nothing if the response has already been sent (writableEnded is true).
+   *
+   * @returns Void. The underlying res.end() return value is not propagated.
+   */
+  send() {
+    if (this.res.writableEnded) return;
+    this.res.writeHead(this.statusCode, this.headers);
+    if (this.body !== null && this.body !== undefined) {
+      this.res.end(this.body);
+    } else {
+      this.res.end();
     }
+  }
 }

package/templates/static/lib/plugin/examples/analytics-plugin.js

@@ -0,0 +1,183 @@
+import { HookStage } from "../types.js";
+/**
+ * Create an analytics plugin.
+ */
+export function createAnalyticsPlugin(config) {
+  const events = [];
+  return {
+    name: "jen-analytics",
+    version: "1.0.0",
+    description: "Track pageviews and events with analytics provider",
+    async init(pluginContext) {
+      console.log(
+        `[Analytics Plugin] Initialized with provider: ${config.provider}`,
+      );
+    },
+    hooks: {
+      // Track pageviews
+      [HookStage.BEFORE_REQUEST]: async (context) => {
+        const path = context.request?.req?.url || "/";
+        const event = {
+          type: "pageview",
+          path,
+          timestamp: Date.now(),
+        };
+        events.push(event);
+        // Send to analytics provider
+        await trackEvent(event, config);
+      },
+      // Inject analytics script into rendered pages
+      [HookStage.AFTER_RENDER]: async (context) => {
+        const analyticsScript = generateAnalyticsScript(config);
+        let html = context.data?.html;
+        if (html) {
+          // Inject before closing body tag
+          html = html.replace("</body>", `${analyticsScript}</body>`);
+          if (context.mutate) {
+            context.mutate("html", html);
+          }
+        }
+      },
+      // Flush events before build
+      [HookStage.BEFORE_BUILD]: async (context) => {
+        console.log(`[Analytics Plugin] Flushing ${events.length} events...`);
+        for (const event of events) {
+          await trackEvent(event, config);
+        }
+        events.length = 0;
+      },
+    },
+  };
+}
+/**
+ * Track an analytics event.
+ */
+async function trackEvent(event, config) {
+  switch (config.provider) {
+    case "google-analytics":
+      await trackGoogleAnalytics(event, config);
+      break;
+    case "segment":
+      await trackSegment(event, config);
+      break;
+    case "mixpanel":
+      await trackMixpanel(event, config);
+      break;
+    case "custom":
+      if (config.customTrackerFn) {
+        await config.customTrackerFn(event);
+      }
+      break;
+  }
+}
+/**
+ * Track event in Google Analytics.
+ */
+async function trackGoogleAnalytics(event, config) {
+  // Mock implementation - in production, use the GA SDK
+  const trackingId = config.trackingId || "UA-XXXXXXXXX-X";
+  const params = new URLSearchParams({
+    v: "1", // API version
+    tid: trackingId,
+    cid: generateClientId(),
+    t: event.type === "pageview" ? "pageview" : "event",
+  });
+  if (event.type === "pageview" && event.path) {
+    params.append("dp", event.path);
+  }
+  if (event.type === "event" && event.eventName) {
+    params.append("ec", "engagement");
+    params.append("ea", event.eventName);
+  }
+  if (config.anonymizeIp) {
+    params.append("aip", "1");
+  }
+  console.log(
+    `[Analytics] GA: ${event.type} → ${event.path || event.eventName}`,
+  );
+  // In production: fetch("https://www.google-analytics.com/collect", { method: "POST", body: params });
+}
+/**
+ * Track event in Segment.
+ */
+async function trackSegment(event, config) {
+  // Mock implementation - in production, use the Segment SDK
+  const apiKey = config.apiKey || "YOUR_SEGMENT_API_KEY";
+  const payload = {
+    type: event.type === "pageview" ? "page" : "track",
+    userId: generateClientId(),
+    timestamp: new Date(event.timestamp).toISOString(),
+    context: {
+      library: { name: "jen.js" },
+    },
+  };
+  if (event.type === "pageview" && event.path) {
+    Object.assign(payload, {
+      name: "Page Viewed",
+      properties: { path: event.path },
+    });
+  }
+  if (event.type === "event" && event.eventName) {
+    Object.assign(payload, {
+      event: event.eventName,
+      properties: event.properties,
+    });
+  }
+  console.log(`[Analytics] Segment: ${event.type}`);
+  // In production: fetch("https://api.segment.io/v1/track", { method: "POST", body: JSON.stringify(payload) });
+}
+/**
+ * Track event in Mixpanel.
+ */
+async function trackMixpanel(event, config) {
+  // Mock implementation - in production, use the Mixpanel SDK
+  const token = config.apiKey || "YOUR_MIXPANEL_TOKEN";
+  const payload = {
+    event: event.type === "pageview" ? "Page View" : event.eventName || "Event",
+    properties: {
+      token,
+      distinct_id: generateClientId(),
+      time: event.timestamp,
+      ...(event.type === "pageview" && event.path ? { page: event.path } : {}),
+      ...event.properties,
+    },
+  };
+  console.log(`[Analytics] Mixpanel: ${payload.event}`);
+  // In production: fetch("https://api.mixpanel.com/track", { method: "POST", body: JSON.stringify([payload]) });
+}
+/**
+ * Generate analytics script to inject into HTML.
+ */
+function generateAnalyticsScript(config) {
+  switch (config.provider) {
+    case "google-analytics":
+      return `
+<script async src="https://www.googletagmanager.com/gtag/js?id=${config.trackingId || "UA-XXXXXXXXX-X"}"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', '${config.trackingId || "UA-XXXXXXXXX-X"}');
+</script>`;
+    case "segment":
+      return `
+<script>
+  !function(){var analytics=window.analytics=window.analytics||[];if(!analytics.initialize)if(analytics.invoked)window.console&&console.error&&console.error("Segment snippet included twice.");else{analytics.invoked=!0;analytics.methods=["trackSubmit","trackClick","trackLink","trackForm","pageview","identify","reset","group","track","ready","alias","debug","page","once","off","on"];analytics.factory=function(e){return function(){var t=Array.prototype.slice.call(arguments);t.unshift(e);analytics.push(t);return analytics}};for(var e=0;e<analytics.methods.length;e++){var t=analytics.methods[e];analytics[t]=analytics.factory(t)}analytics.load=function(e,t){var n=document.createElement("script");n.type="text/javascript";n.async=!0;n.src="https://cdn.segment.com/analytics.js/v1/"+e+"/analytics.min.js";var a=document.getElementsByTagName("script")[0];a.parentNode.insertBefore(n,a);analytics._loadOptions=t};analytics.SNIPPET_VERSION="4.4.0";analytics.load("${config.apiKey || "YOUR_SEGMENT_API_KEY"}");analytics.page();}}();
+</script>`;
+    case "mixpanel":
+      return `
+<script async src="//cdn.mxpnl.com/libs/mixpanel-latest.min.js"></script>
+<script>
+  mixpanel.init("${config.apiKey || "YOUR_MIXPANEL_TOKEN"}");
+  mixpanel.track("Page Viewed");
+</script>`;
+    default:
+      return "";
+  }
+}
+/**
+ * Generate a unique client ID.
+ */
+function generateClientId() {
+  return Math.random().toString(36).substring(2) + Date.now().toString(36);
+}

package/templates/static/lib/plugin/examples/cdn-upload-plugin.js

@@ -0,0 +1,94 @@
+import { HookStage } from "../types.js";
+/**
+ * Create a CDN upload plugin.
+ */
+export function createCDNUploadPlugin(config) {
+  return {
+    name: "jen-cdn-upload",
+    version: "1.0.0",
+    description: "Upload optimized assets to CDN after build",
+    async init(pluginContext) {
+      console.log(`[CDN Plugin] Initialized with provider: ${config.provider}`);
+    },
+    hooks: {
+      // Hook after build completes to upload assets
+      [HookStage.AFTER_BUILD]: async (context) => {
+        console.log("[CDN Plugin] Build completed, uploading assets...");
+        // Get the list of optimized assets from the build context
+        const { distDir } = context.config;
+        const assets = context.data?.assets || [];
+        for (const asset of assets) {
+          try {
+            const cdnUrl = await uploadAsset(asset, config);
+            console.log(`[CDN Plugin] Uploaded: ${asset.path} → ${cdnUrl}`);
+            // Update the asset URL in the manifest
+            if (!context.data?.assetUrls) {
+              context.data = { ...context.data, assetUrls: {} };
+            }
+            context.data.assetUrls[asset.path] = cdnUrl;
+          } catch (error) {
+            console.error(
+              `[CDN Plugin] Failed to upload ${asset.path}:`,
+              error,
+            );
+            throw error;
+          }
+        }
+      },
+      // Hook to inject CDN URLs into HTML
+      [HookStage.AFTER_RENDER]: async (context) => {
+        const assetUrls = context.data?.assetUrls || {};
+        if (Object.keys(assetUrls).length > 0) {
+          // Update HTML with CDN URLs
+          let html = context.data?.html;
+          for (const [localPath, cdnUrl] of Object.entries(assetUrls)) {
+            html = html?.replace(new RegExp(localPath, "g"), cdnUrl);
+          }
+          if (context.mutate) {
+            context.mutate("html", html);
+          }
+        }
+      },
+    },
+  };
+}
+/**
+ * Upload a single asset to the configured CDN.
+ */
+async function uploadAsset(file, config) {
+  switch (config.provider) {
+    case "cloudinary":
+      return uploadToCloudinary(file, config);
+    case "aws-s3":
+      return uploadToS3(file, config);
+    case "custom":
+      if (config.customUploadFn) {
+        return config.customUploadFn(file);
+      }
+      throw new Error("Custom upload function not provided");
+    default:
+      throw new Error(`Unsupported CDN provider: ${config.provider}`);
+  }
+}
+/**
+ * Upload to Cloudinary.
+ */
+async function uploadToCloudinary(file, config) {
+  // This is a mock implementation
+  // In production, use the Cloudinary SDK
+  const cloudName = config.cloudName || "demo";
+  const filename = file.path.split("/").pop() || "asset";
+  // Mock response - in reality, call Cloudinary API
+  return `https://res.cloudinary.com/${cloudName}/image/upload/v1/${filename}`;
+}
+/**
+ * Upload to AWS S3.
+ */
+async function uploadToS3(file, config) {
+  // This is a mock implementation
+  // In production, use the AWS SDK
+  const bucket = config.bucket || "my-assets";
+  const key = file.path;
+  // Mock response - in reality, call S3 API
+  return `https://${bucket}.s3.amazonaws.com/${key}`;
+}

package/templates/static/lib/plugin/loader.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/>.
- */
 // Plugin loader
 // Migrated from Python src/python/plugins.py
 import { readdirSync } from "node:fs";
@@ -23,37 +6,31 @@ import { pathToFileURL } from "node:url";
 import { log } from "../shared/log.js";
 const PLUGIN_DIR = "src/plugin/plugins";
 export async function runPlugins(event = "build") {
-    log.info(`Running plugins (${event})...`);
-    try {
-        const files = readdirSync(PLUGIN_DIR);
-        for (const file of files) {
-            if (!file.endsWith(".ts") && !file.endsWith(".js"))
-                continue;
-            const pluginPath = join(process.cwd(), PLUGIN_DIR, file);
-            const pluginUrl = pathToFileURL(pluginPath).href;
-            try {
-                const module = (await import(pluginUrl));
-                const plugin = module.default;
-                if (!plugin)
-                    continue;
-                log.info(`  Loading plugin: ${plugin.name}`);
-                if (event === "build" && plugin.onBuild) {
-                    await plugin.onBuild();
-                }
-                else if (event === "serve" && plugin.onServe) {
-                    await plugin.onServe();
-                }
-                else if (event === "deploy" && plugin.onDeploy) {
-                    await plugin.onDeploy();
-                }
-            }
-            catch (err) {
-                log.error(`  Plugin error: ${file} - ${String(err)}`);
-            }
+  log.info(`Running plugins (${event})...`);
+  try {
+    const files = readdirSync(PLUGIN_DIR);
+    for (const file of files) {
+      if (!file.endsWith(".ts") && !file.endsWith(".js")) continue;
+      const pluginPath = join(process.cwd(), PLUGIN_DIR, file);
+      const pluginUrl = pathToFileURL(pluginPath).href;
+      try {
+        const module = await import(pluginUrl);
+        const plugin = module.default;
+        if (!plugin) continue;
+        log.info(`  Loading plugin: ${plugin.name}`);
+        if (event === "build" && plugin.onBuild) {
+          await plugin.onBuild();
+        } else if (event === "serve" && plugin.onServe) {
+          await plugin.onServe();
+        } else if (event === "deploy" && plugin.onDeploy) {
+          await plugin.onDeploy();
         }
-        log.info("Plugins executed.");
-    }
-    catch (err) {
-        log.warn(`Plugin directory not found: ${PLUGIN_DIR}`);
+      } catch (err) {
+        log.error(`  Plugin error: ${file} - ${String(err)}`);
+      }
     }
+    log.info("Plugins executed.");
+  } catch (err) {
+    log.warn(`Plugin directory not found: ${PLUGIN_DIR}`);
+  }
 }