@moonsjs/vite 0.1.15 → 0.1.17

package/src/server/logger.ts

@@ -0,0 +1,69 @@
+/**
+ * Addendum L.3: logger akses terstruktur — JSON default, redaksi nilai
+ * query-param (mis. `?token=…`), dan target tulis injectable (untuk test).
+ * Semua field tambahan diteruskan apa adanya; `path` selalu di-redaksi.
+ */
+export interface LogEvent {
+  /** Default `info`. */
+  level?: "info" | "warn" | "error";
+  /** Nama event, mis. `request` atau `isr:regenerated`. */
+  msg: string;
+  [field: string]: unknown;
+}
+
+export interface LoggerOptions {
+  /** Default `true` (JSON). `false` = teks ringkas. */
+  json?: boolean;
+  /** Nama query-param yang nilainya diganti `[redacted]`. */
+  redact?: readonly string[];
+  /** Tujuan tulis; default `console.log`. */
+  write?: (line: string) => void;
+}
+
+export type Logger = (event: LogEvent) => void;
+
+/** Ganti nilai query-param bernama `redact` menjadi `[redacted]`. */
+export function redactPath(path: string, redact: readonly string[]): string {
+  if (redact.length === 0 || !path.includes("?")) {
+    return path;
+  }
+  const index = path.indexOf("?");
+  const pathname = path.slice(0, index);
+  const params = new URLSearchParams(path.slice(index + 1));
+  let changed = false;
+  for (const name of redact) {
+    if (params.has(name)) {
+      params.set(name, "[redacted]");
+      changed = true;
+    }
+  }
+  return changed ? `${pathname}?${params.toString()}` : path;
+}
+
+export function createLogger(options: LoggerOptions = {}): Logger {
+  const json = options.json !== false;
+  const redact = options.redact ?? [];
+  const write = options.write ?? ((line: string): void => console.log(line));
+
+  return (event) => {
+    const fields: Record<string, unknown> = { level: "info", ...event };
+    if (typeof fields["path"] === "string") {
+      fields["path"] = redactPath(fields["path"], redact);
+    }
+    if (json) {
+      write(JSON.stringify({ time: new Date().toISOString(), ...fields }));
+      return;
+    }
+    const parts = ["[moons]", String(fields["level"]).toUpperCase(), String(fields["msg"])];
+    if (fields["path"] !== undefined) {
+      parts.push(String(fields["path"]));
+    }
+    if (fields["status"] !== undefined) {
+      parts.push(String(fields["status"]));
+    }
+    if (fields["durationMs"] !== undefined) {
+      parts.push(`${String(fields["durationMs"])}ms`);
+    }
+    write(parts.join(" "));
+  };
+}

package/src/server/node-server.ts

@@ -2,17 +2,24 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { gzipSync } from "node:zlib";
 import { createServer, type Server } from "node:http";
 import { extname, join, resolve, sep } from "node:path";
-import { DEFAULT_BODY_LIMIT_BYTES, MoonsError, type PrerenderStorage } from "@moonsjs/core";
+import {
+  DEFAULT_BODY_LIMIT_BYTES,
+  MoonsError,
+  trailingSlashRedirect,
+  type PrerenderStorage,
+} from "@moonsjs/core";
 import { revalidatePrerendered, shouldRevalidate } from "./isr";
 import { contentTypeForPathname } from "./storage";
 import {
   BodyLimitError,
   DEFAULT_SECURITY_HEADERS,
   InvalidRequestError,
+  resolveClientIp,
   resolveRequestUrl,
   sendNodeResponse,
   toWebRequest,
 } from "./node";
+import { createLogger, type Logger } from "./logger";
 import type { PluginRuntime } from "./plugins";
 import { installGracefulShutdown } from "./shutdown";
 
@@ -64,6 +71,10 @@ export interface NodeServerOptions {
   trustProxy?: boolean;
   /** Addendum J.2: batas body RPC di transport (default `DEFAULT_BODY_LIMIT_BYTES`). */
   bodyLimitBytes?: number;
+  /** Addendum L.3: log akses terstruktur (default senyap). */
+  logging?: { accessLog?: boolean; json?: boolean; redact?: string[] };
+  /** Addendum M: kebijakan trailing slash (juga untuk path prerender/static). */
+  trailingSlash?: "never" | "always";
 }
 
 /**
@@ -77,7 +88,29 @@ export function startNodeServer(
   const clientDir = resolve(options.clientDir ?? join(process.cwd(), "dist/client"));
   const port = options.port ?? Number(process.env["PORT"] ?? 3000);
 
+  const accessLogger: Logger | null =
+    options.logging?.accessLog === true
+      ? createLogger({
+          json: options.logging.json !== false,
+          redact: options.logging.redact ?? [],
+        })
+      : null;
+
   const server = createServer((req, res) => {
+    const requestStartedAt = performance.now();
+    if (accessLogger !== null) {
+      res.once("finish", () => {
+        const ip = resolveClientIp(req, options.trustProxy === true);
+        accessLogger({
+          msg: "request",
+          method: req.method ?? "GET",
+          path: req.url ?? "/",
+          status: res.statusCode,
+          durationMs: Math.round(performance.now() - requestStartedAt),
+          ...(ip === null ? {} : { ip }),
+        });
+      });
+    }
     void (async () => {
       let url: URL;
       try {
@@ -94,6 +127,19 @@ export function startNodeServer(
       }
 
       try {
+        // Addendum M: kanonikalisasi trailing slash di transport — mencakup
+        // path prerender yang dilayani langsung (tidak lewat handler).
+        if (options.trailingSlash !== undefined) {
+          const canonical = trailingSlashRedirect(url.pathname, options.trailingSlash);
+          if (canonical !== null) {
+            url.pathname = canonical;
+            res.statusCode = 308;
+            res.setHeader("location", url.toString());
+            res.end();
+            return;
+          }
+        }
+
         if (req.method === "GET" || req.method === "HEAD") {
           // Addendum I: storage bersama (bila dikonfigurasi) diutamakan.
           if (options.storage !== undefined) {
@@ -106,6 +152,7 @@ export function startNodeServer(
                 handler,
                 options,
                 clientDir,
+                logger: accessLogger,
               });
               res.statusCode = 200;
               res.setHeader("content-type", contentTypeForPathname(url.pathname));
@@ -129,6 +176,7 @@ export function startNodeServer(
                 handler,
                 options,
                 clientDir,
+                logger: accessLogger,
               });
               const body = readFileSync(staticFile);
               const stat = statSync(staticFile);
@@ -444,6 +492,7 @@ function scheduleRevalidation(input: {
   handler: (request: Request) => Promise<Response>;
   options: NodeServerOptions;
   clientDir: string;
+  logger?: Logger | null;
 }): void {
   const normalized = input.pathname.length > 1 ? input.pathname.replace(/\/+$/, "") : input.pathname;
   const seconds = readPrerenderManifest(input.clientDir).revalidate.get(normalized);
@@ -453,6 +502,8 @@ function scheduleRevalidation(input: {
   if (!shouldRevalidate({ mtimeMs: input.mtimeMs, revalidateSeconds: seconds })) {
     return;
   }
+  const regeneratedAt = performance.now();
+  const logger = input.logger ?? null;
   void revalidatePrerendered({
     pathname: normalized,
     ...(input.file === undefined ? {} : { file: input.file }),
@@ -460,6 +511,21 @@ function scheduleRevalidation(input: {
     handler: input.handler,
     ...(input.options.canary === undefined ? {} : { canary: input.options.canary }),
     env: process.env,
-  });
+  })
+    .then(() => {
+      logger?.({
+        msg: "isr:regenerated",
+        path: normalized,
+        durationMs: Math.round(performance.now() - regeneratedAt),
+      });
+    })
+    .catch((error: unknown) => {
+      const message = error instanceof Error ? error.message : String(error);
+      if (logger !== null) {
+        logger({ msg: "isr:revalidate-failed", level: "warn", path: normalized, error: message });
+      } else {
+        console.error(`[moons] isr regenerasi gagal (${normalized}): ${message}`);
+      }
+    });
 }