jskelet 0.2.5 → 0.3.0

package/src/runtime/alias-hooks.mjs

@@ -1,119 +1,119 @@
-/**
- * Node ESM resolve hook'ları. İki iş yapar:
- *
- * 1. `jsconfig.json` / `tsconfig.json` içindeki `compilerOptions.paths`
- *    alias'larını çözer (`@/lib/x` → `<root>/lib/x`). Editör ve çalışma zamanı
- *    aynı dosyadan beslendiği için ikisi birbirinden ayrışmaz.
- * 2. Uzantısız göreli import'lara uzantı ekler (`./cache` → `./cache.js`).
- *    Node ESM bunu yapmaz; bundler'dan taşınan kodda en sık karşılaşılan
- *    kırılma noktası bu.
- *
- * `node --import jskelet/register` ile kurulur.
- */
-import fs from "node:fs";
-import path from "node:path";
-import process from "node:process";
-import { fileURLToPath, pathToFileURL } from "node:url";
-
-const ROOT = process.cwd();
-
-/** Uzantısız hedefler için denenecek sıra. */
-const EXTENSIONS = [".js", ".mjs", ".json", "/index.js", "/index.mjs"];
-
-/**
- * @returns {{ prefix: string, target: string }[]}
- */
-function readAliases() {
-  for (const name of ["jsconfig.json", "tsconfig.json"]) {
-    const file = path.join(ROOT, name);
-    if (!fs.existsSync(file)) continue;
-
-    try {
-      // Yorum içerebilen tsconfig'ler için kaba ama yeterli bir temizlik;
-      // tam bir JSON5 ayrıştırıcısı bağımlılık eklemeye değmiyor.
-      const raw = fs
-        .readFileSync(file, "utf8")
-        .replace(/\/\*[\s\S]*?\*\//g, "")
-        .replace(/^\s*\/\/.*$/gm, "");
-
-      const config = JSON.parse(raw);
-      const baseUrl = path.resolve(ROOT, config.compilerOptions?.baseUrl ?? ".");
-      const paths = config.compilerOptions?.paths ?? {};
-
-      /** @type {{ prefix: string, target: string }[]} */
-      const aliases = [];
-
-      for (const [pattern, targets] of Object.entries(paths)) {
-        const target = Array.isArray(targets) ? targets[0] : targets;
-        if (!pattern.endsWith("/*") || typeof target !== "string") continue;
-
-        aliases.push({
-          prefix: pattern.slice(0, -1),
-          target: path.resolve(baseUrl, target.slice(0, -1)),
-        });
-      }
-
-      // Uzun önek önce: `@flags/` `@/`den önce denenmeli, yoksa `@/` yakalar.
-      return aliases.sort((a, b) => b.prefix.length - a.prefix.length);
-    } catch (error) {
-      console.warn(`[alias] could not read ${name}, aliases disabled`, error);
-      return [];
-    }
-  }
-
-  return [];
-}
-
-const ALIASES = readAliases();
-
-/**
- * @param {string} filePath
- * @returns {boolean}
- */
-function isFile(filePath) {
-  try {
-    return fs.statSync(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-
-/**
- * @param {string} filePath
- * @returns {string | null}
- */
-function resolveFile(filePath) {
-  if (path.extname(filePath) && isFile(filePath)) return filePath;
-
-  for (const suffix of EXTENSIONS) {
-    const candidate = `${filePath}${suffix}`;
-    if (isFile(candidate)) return candidate;
-  }
-
-  return isFile(filePath) ? filePath : null;
-}
-
-export async function resolve(specifier, context, nextResolve) {
-  for (const { prefix, target } of ALIASES) {
-    if (!specifier.startsWith(prefix)) continue;
-
-    const base = path.join(target, specifier.slice(prefix.length));
-    const resolved = resolveFile(base);
-
-    return nextResolve(pathToFileURL(resolved ?? base).href, context);
-  }
-
-  if (
-    (specifier.startsWith("./") || specifier.startsWith("../")) &&
-    !path.extname(specifier) &&
-    context.parentURL?.startsWith("file:")
-  ) {
-    const parentDir = path.dirname(fileURLToPath(context.parentURL));
-    const base = path.resolve(parentDir, specifier);
-    const resolved = resolveFile(base);
-
-    if (resolved) return nextResolve(pathToFileURL(resolved).href, context);
-  }
-
-  return nextResolve(specifier, context);
-}
+/**
+ * Node ESM resolve hook'ları. İki iş yapar:
+ *
+ * 1. `jsconfig.json` / `tsconfig.json` içindeki `compilerOptions.paths`
+ *    alias'larını çözer (`@/lib/x` → `<root>/lib/x`). Editör ve çalışma zamanı
+ *    aynı dosyadan beslendiği için ikisi birbirinden ayrışmaz.
+ * 2. Uzantısız göreli import'lara uzantı ekler (`./cache` → `./cache.js`).
+ *    Node ESM bunu yapmaz; bundler'dan taşınan kodda en sık karşılaşılan
+ *    kırılma noktası bu.
+ *
+ * `node --import jskelet/register` ile kurulur.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const ROOT = process.cwd();
+
+/** Uzantısız hedefler için denenecek sıra. */
+const EXTENSIONS = [".js", ".mjs", ".json", "/index.js", "/index.mjs"];
+
+/**
+ * @returns {{ prefix: string, target: string }[]}
+ */
+function readAliases() {
+  for (const name of ["jsconfig.json", "tsconfig.json"]) {
+    const file = path.join(ROOT, name);
+    if (!fs.existsSync(file)) continue;
+
+    try {
+      // Yorum içerebilen tsconfig'ler için kaba ama yeterli bir temizlik;
+      // tam bir JSON5 ayrıştırıcısı bağımlılık eklemeye değmiyor.
+      const raw = fs
+        .readFileSync(file, "utf8")
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/^\s*\/\/.*$/gm, "");
+
+      const config = JSON.parse(raw);
+      const baseUrl = path.resolve(ROOT, config.compilerOptions?.baseUrl ?? ".");
+      const paths = config.compilerOptions?.paths ?? {};
+
+      /** @type {{ prefix: string, target: string }[]} */
+      const aliases = [];
+
+      for (const [pattern, targets] of Object.entries(paths)) {
+        const target = Array.isArray(targets) ? targets[0] : targets;
+        if (!pattern.endsWith("/*") || typeof target !== "string") continue;
+
+        aliases.push({
+          prefix: pattern.slice(0, -1),
+          target: path.resolve(baseUrl, target.slice(0, -1)),
+        });
+      }
+
+      // Uzun önek önce: `@flags/` `@/`den önce denenmeli, yoksa `@/` yakalar.
+      return aliases.sort((a, b) => b.prefix.length - a.prefix.length);
+    } catch (error) {
+      console.warn(`[alias] could not read ${name}, aliases disabled`, error);
+      return [];
+    }
+  }
+
+  return [];
+}
+
+const ALIASES = readAliases();
+
+/**
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+function isFile(filePath) {
+  try {
+    return fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {string} filePath
+ * @returns {string | null}
+ */
+function resolveFile(filePath) {
+  if (path.extname(filePath) && isFile(filePath)) return filePath;
+
+  for (const suffix of EXTENSIONS) {
+    const candidate = `${filePath}${suffix}`;
+    if (isFile(candidate)) return candidate;
+  }
+
+  return isFile(filePath) ? filePath : null;
+}
+
+export async function resolve(specifier, context, nextResolve) {
+  for (const { prefix, target } of ALIASES) {
+    if (!specifier.startsWith(prefix)) continue;
+
+    const base = path.join(target, specifier.slice(prefix.length));
+    const resolved = resolveFile(base);
+
+    return nextResolve(pathToFileURL(resolved ?? base).href, context);
+  }
+
+  if (
+    (specifier.startsWith("./") || specifier.startsWith("../")) &&
+    !path.extname(specifier) &&
+    context.parentURL?.startsWith("file:")
+  ) {
+    const parentDir = path.dirname(fileURLToPath(context.parentURL));
+    const base = path.resolve(parentDir, specifier);
+    const resolved = resolveFile(base);
+
+    if (resolved) return nextResolve(pathToFileURL(resolved).href, context);
+  }
+
+  return nextResolve(specifier, context);
+}

package/src/runtime/register.mjs

@@ -1,4 +1,4 @@
-/** `node --import jskelet/register` ile alias hook'unu kaydeder. */
-import { register } from "node:module";
-
-register("./alias-hooks.mjs", import.meta.url);
+/** `node --import jskelet/register` ile alias hook'unu kaydeder. */
+import { register } from "node:module";
+
+register("./alias-hooks.mjs", import.meta.url);

package/src/server/admin/actions.js

@@ -0,0 +1,229 @@
+/**
+ * Admin paneli mutasyonları. Cevap metin değil `{ ok, code, params }` —
+ * i18n client'ta.
+ */
+import {
+  clearHtmlCache,
+  dropHtmlCacheKey,
+  getHtmlCacheSize,
+  invalidateHtmlCache,
+} from "../html-cache.js";
+import {
+  clearDataCache,
+  dropDataCacheKey,
+} from "../data-cache.js";
+import {
+  getRedisStatus,
+  inspectRedis,
+  redisDropMatching,
+} from "../redis.js";
+import {
+  clearCloudflareCacheReserve,
+  purgeCloudflare,
+  setCloudflareFeature,
+  setCloudflareSetting,
+  toCloudflareUrls,
+} from "../cloudflare.js";
+import { prewarm, prewarmProgress } from "../prewarm.js";
+
+/**
+ * @param {Record<string, any>} body
+ * @param {import('express').Request} req
+ * @returns {Promise<{ ok: boolean, code?: string,
+ *   params?: Record<string, string | number>,
+ *   parts?: ({ code: string, params?: Record<string, string | number> } | null)[] }>}
+ */
+export async function runAction(body, req) {
+  const type = String(body?.type ?? "");
+
+  switch (type) {
+    case "html:clear": {
+      const size = getHtmlCacheSize();
+      clearHtmlCache();
+      return { ok: true, code: "html.cleared", params: { count: size } };
+    }
+
+    case "data:clear": {
+      const prefix = typeof body.prefix === "string" && body.prefix ? body.prefix : undefined;
+      const removed = clearDataCache(prefix);
+      return prefix
+        ? { ok: true, code: "data.clearedPrefix", params: { count: removed, prefix } }
+        : { ok: true, code: "data.cleared", params: { count: removed } };
+    }
+
+    case "html:invalidate": {
+      const target = String(body.target ?? "");
+      if (!target.startsWith("/")) {
+        return { ok: false, code: "target.invalid" };
+      }
+
+      const hard = body.hard === true;
+      const count = invalidateHtmlCache(target, { hard });
+      return {
+        ok: true,
+        code: hard ? "html.dropped" : "html.marked",
+        params: { count, target },
+      };
+    }
+
+    case "html:drop": {
+      const key = String(body.key ?? "");
+      if (!key) return { ok: false, code: "key.missing" };
+      const existed = dropHtmlCacheKey(key);
+      return { ok: true, code: existed ? "entry.dropped" : "entry.absent", params: { key } };
+    }
+
+    case "data:drop": {
+      const key = String(body.key ?? "");
+      if (!key) return { ok: false, code: "key.missing" };
+      const existed = dropDataCacheKey(key);
+      return { ok: true, code: existed ? "entry.dropped" : "entry.absent", params: { key } };
+    }
+
+    case "redis:inspect": {
+      const result = await inspectRedis();
+      if (!result.ok) return { ok: false, code: "redis.unreachable" };
+
+      return {
+        ok: true,
+        parts: [
+          { code: "redis.htmlKeys", params: { count: result.html } },
+          { code: "redis.dataKeys", params: { count: result.data } },
+          result.totalKeys !== null
+            ? { code: "redis.dbKeys", params: { count: result.totalKeys } }
+            : null,
+          result.usedMemory ? { code: "redis.memory", params: { value: result.usedMemory } } : null,
+        ].filter(Boolean),
+      };
+    }
+
+    case "redis:drop": {
+      const kind = body.kind === "data" ? "data" : "html";
+      const status = getRedisStatus();
+      if (!status.connected) {
+        return { ok: false, code: "redis.notConnected" };
+      }
+
+      const dropped = await redisDropMatching(kind);
+      return {
+        ok: true,
+        code: kind === "data" ? "redis.droppedData" : "redis.droppedHtml",
+        params: { count: dropped },
+      };
+    }
+
+    case "cf:purge-everything": {
+      const result = await purgeCloudflare({ everything: true });
+      return result.ok
+        ? { ok: true, code: "cf.purgedEverything" }
+        : cloudflareFailure(result.error);
+    }
+
+    case "cf:purge-urls": {
+      const paths = Array.isArray(body.paths) ? body.paths.map(String) : [];
+      if (!paths.length) return { ok: false, code: "cf.noPaths" };
+
+      const urls = toCloudflareUrls(paths, originOf(req));
+      if (!urls.length) return { ok: false, code: "cf.noHostname" };
+
+      const result = await purgeCloudflare({ files: urls });
+      return result.ok
+        ? {
+            ok: true,
+            code: "cf.purgedUrls",
+            params: { count: result.purged, batches: result.batches },
+          }
+        : cloudflareFailure(result.error);
+    }
+
+    case "cf:purge-keys": {
+      /** @type {"prefixes" | "hosts" | "tags"} */
+      const kind =
+        body.kind === "hosts" ? "hosts" : body.kind === "tags" ? "tags" : "prefixes";
+
+      const values = String(body.values ?? "")
+        .split(/[\s,]+/)
+        .filter(Boolean);
+
+      if (!values.length) return { ok: false, code: "cf.nothingToPurge" };
+
+      const result = await purgeCloudflare({ [kind]: values });
+      return result.ok
+        ? { ok: true, code: "cf.purgedKeys", params: { count: result.purged, kind } }
+        : cloudflareFailure(result.error);
+    }
+
+    case "cf:setting": {
+      const result = await setCloudflareSetting(body.id, body.value);
+      return result.ok
+        ? {
+            ok: true,
+            code: "cf.settingChanged",
+            params: { id: String(body.id), value: String(result.value) },
+          }
+        : cloudflareFailure(result.error);
+    }
+
+    case "cf:feature": {
+      const value = body.value === "on" ? "on" : "off";
+      const result = await setCloudflareFeature(body.feature, value);
+      return result.ok
+        ? {
+            ok: true,
+            code: "cf.featureChanged",
+            params: { feature: String(body.feature), value },
+          }
+        : cloudflareFailure(result.error);
+    }
+
+    case "cf:clear-reserve": {
+      const result = await clearCloudflareCacheReserve();
+      return result.ok
+        ? { ok: true, code: "cf.reserveClearing" }
+        : cloudflareFailure(result.error);
+    }
+
+    case "prewarm": {
+      if (prewarmProgress.active) {
+        return { ok: false, code: "prewarm.busy" };
+      }
+
+      const requested = Array.isArray(body.paths) ? body.paths : [];
+      const paths = requested.filter(
+        (/** @type {unknown} */ value) =>
+          typeof value === "string" && value.startsWith("/"),
+      );
+
+      prewarm({
+        origin: `${req.protocol}://${req.get("host")}`,
+        paths: paths.length ? paths : undefined,
+      }).catch((error) => {
+        console.error("[admin] prewarm failed", error);
+      });
+
+      return paths.length
+        ? { ok: true, code: "prewarm.paths", params: { count: paths.length } }
+        : { ok: true, code: "prewarm.all" };
+    }
+
+    default:
+      return { ok: false, code: "action.unknown", params: { type } };
+  }
+}
+
+/**
+ * @param {string | undefined} error
+ * @returns {{ ok: false, code: string, params: { error: string } }}
+ */
+function cloudflareFailure(error) {
+  return { ok: false, code: "cf.failed", params: { error: error ?? "unknown error" } };
+}
+
+/**
+ * @param {import('express').Request} req
+ * @returns {string | undefined}
+ */
+function originOf(req) {
+  const host = req.get("host");
+  return host ? `${req.protocol}://${host}` : undefined;
+}

package/src/server/admin/auth.js

@@ -0,0 +1,125 @@
+/**
+ * Admin paneli oturum ve şifre yönetimi.
+ *
+ * Şifre süreç ömrü kadar; kalıcı sır yok. Cookie parse framework'ün
+ * `parseCookies()` yolunu kullanmaz — o yol isteği "kişiselleştirilmiş"
+ * işaretler.
+ */
+import crypto from "node:crypto";
+import process from "node:process";
+import { safeEqual } from "../../http/cookies.js";
+
+export const COOKIE_NAME = "jskelet_admin_sid";
+
+/**
+ * Aksiyon isteklerinde beklenen başlık. Tarayıcı bu başlığı çapraz site bir
+ * formla gönderemez (preflight gerekir), yani panelin kendi CSRF freni.
+ */
+export const ACTION_HEADER = "x-jskelet-admin";
+
+/** 32 haneli, süreç ömrü kadar geçerli şifre. */
+export const PASSWORD = crypto.randomBytes(16).toString("hex");
+
+/** @type {Map<string, number>} token → son kullanma zamanı. */
+const sessions = new Map();
+
+/**
+ * @param {import('express').Request} req
+ * @param {string} name
+ * @returns {string | null}
+ */
+export function readCookie(req, name) {
+  const header = req.headers.cookie;
+  if (!header) return null;
+
+  for (const part of header.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    if (part.slice(0, eq).trim() !== name) continue;
+    return decodeURIComponent(part.slice(eq + 1).trim());
+  }
+
+  return null;
+}
+
+/**
+ * Süresi geçmiş oturumları eler.
+ */
+export function pruneSessions() {
+  const now = Date.now();
+  for (const [token, expiresAt] of sessions) {
+    if (now >= expiresAt) sessions.delete(token);
+  }
+}
+
+/**
+ * @param {import('express').Request} req
+ * @returns {boolean}
+ */
+export function authenticated(req) {
+  const token = readCookie(req, COOKIE_NAME);
+  if (!token) return false;
+
+  const expiresAt = sessions.get(token);
+  if (expiresAt === undefined) return false;
+
+  if (Date.now() >= expiresAt) {
+    sessions.delete(token);
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * @param {string} password
+ * @returns {boolean}
+ */
+export function passwordMatches(password) {
+  return Boolean(password) && safeEqual(password, PASSWORD);
+}
+
+/**
+ * @param {number} sessionHours
+ * @returns {{ token: string, maxAge: number }}
+ */
+export function createSession(sessionHours) {
+  pruneSessions();
+  const token = crypto.randomBytes(32).toString("base64url");
+  const maxAge = Math.round(sessionHours * 3600);
+  sessions.set(token, Date.now() + maxAge * 1000);
+  return { token, maxAge };
+}
+
+/**
+ * @param {import('express').Request} req
+ */
+export function destroySession(req) {
+  const token = readCookie(req, COOKIE_NAME);
+  if (token) sessions.delete(token);
+}
+
+/**
+ * @param {string} basePath
+ * @param {string} token
+ * @param {number} maxAge
+ * @returns {string}
+ */
+export function sessionCookie(basePath, token, maxAge) {
+  return [
+    `${COOKIE_NAME}=${token}`,
+    `Path=${basePath}`,
+    `Max-Age=${maxAge}`,
+    "HttpOnly",
+    "SameSite=Strict",
+    ...(process.env.NODE_ENV === "development" ? [] : ["Secure"]),
+  ].join("; ");
+}
+
+/**
+ * @param {string} basePath
+ * @returns {string}
+ */
+export function clearSessionCookie(basePath) {
+  return `${COOKIE_NAME}=; Path=${basePath}; Max-Age=0`;
+}