@stacksjs/stx 0.2.94 → 0.2.96

package/dist/ssr.js

@@ -1,2 +1,355 @@
-// @bun
-import{ng as a,og as b,pg as c}from"./chunk-xsqbk4yk.js";import"./chunk-w01y57f5.js";import"./chunk-x1hjv24z.js";import"./chunk-0g4gece6.js";import"./chunk-nap11ntr.js";import"./chunk-03c26pjz.js";import"./chunk-13yz561y.js";import"./chunk-nanw7yhz.js";import"./chunk-ghrx0hn1.js";import"./chunk-82t27pvd.js";import"./chunk-fhawx87n.js";import"./chunk-gc84b1d2.js";import"./chunk-yr1gdceh.js";import"./chunk-baa7h4yz.js";import"./chunk-kdxa9epn.js";import"./chunk-g2hekckm.js";import"./chunk-x39sfpvm.js";import"./chunk-tr0z0e1g.js";import"./chunk-4j188175.js";import"./chunk-eds0f8f1.js";import"./chunk-dyjnn5k8.js";import"./chunk-8fgwhhb8.js";import"./chunk-tj6zfxeb.js";import"./chunk-7xcfy2fn.js";import"./chunk-9yz5d003.js";import"./chunk-fms20x0n.js";import"./chunk-fe7r1mq1.js";import"./chunk-rb1e4cnb.js";import"./chunk-j4s5qwd7.js";import"./chunk-b0cyc09a.js";import"./chunk-0tatqxj2.js";import"./chunk-bykjk6vj.js";import"./chunk-7b0xdy5h.js";import"./chunk-ywkrxp2h.js";import"./chunk-y25pr13j.js";import"./chunk-q6h6yvzb.js";import"./chunk-qdc3aav1.js";import"./chunk-6wn85hn6.js";import"./chunk-qd5461tt.js";import"./chunk-77tga15w.js";import"./chunk-rv002yn0.js";import"./chunk-hke99a0v.js";import"./chunk-mwbng54r.js";import"./chunk-wxvyj65q.js";import"./chunk-yw2fzq86.js";import"./chunk-mrehzhxv.js";import"./chunk-1zgsgk4b.js";import"./chunk-48cw2nde.js";import"./chunk-jjvp4t5w.js";import"./chunk-94g3cahw.js";import"./chunk-ht4j68cs.js";import"./chunk-fch9tk1k.js";import"./chunk-cz25azze.js";import"./chunk-q60knhjf.js";import"./chunk-hrampcrj.js";import"./chunk-t37dp99j.js";import"./chunk-5kt3ay7x.js";import"./chunk-95w08s8v.js";import"./chunk-ceg2c2q2.js";import"./chunk-04mvcmcr.js";import"./chunk-n46a5g1g.js";import"./chunk-vv9wfz1c.js";import"./chunk-dzw95th7.js";import"./chunk-46mkpbkk.js";import"./chunk-3rh7va1z.js";import"./chunk-2xen423s.js";import"./chunk-cp3kwv17.js";import"./chunk-hpqr9e3x.js";import"./chunk-adqh2m9z.js";import"./chunk-8qbax8xn.js";import"./chunk-x64kb787.js";import"./chunk-gcf5v18y.js";import"./chunk-pc31m5x5.js";import"./chunk-3jm3snz8.js";export{b as render,c as createApp,a as MemorySessionStore};
+import crypto from "node:crypto";
+import path from "node:path";
+import { errorLogger } from "./error-handling.js";
+import { processDirectives } from "./process.js";
+import { extractVariables } from "./utils.js";
+
+export class MemorySessionStore {
+  store = new Map;
+  async get(sessionId) {
+    const entry = this.store.get(sessionId);
+    if (!entry || entry.expires <= Date.now()) {
+      if (entry)
+        this.store.delete(sessionId);
+      return null;
+    }
+    return { ...entry.data };
+  }
+  async set(sessionId, data, ttlSeconds) {
+    this.store.set(sessionId, { data: { ...data }, expires: Date.now() + ttlSeconds * 1000 });
+  }
+  async delete(sessionId) {
+    this.store.delete(sessionId);
+  }
+}
+async function createSession(sessionId, ttl, store) {
+  const sessionData = {}, flashData = {}, existing = await store.get(sessionId);
+  if (existing)
+    Object.assign(sessionData, existing);
+  const session = {
+    id: sessionId,
+    data: sessionData,
+    get(key) {
+      return sessionData[key];
+    },
+    set(key, value) {
+      sessionData[key] = value;
+      saveSession();
+    },
+    delete(key) {
+      delete sessionData[key];
+      saveSession();
+    },
+    clear() {
+      Object.keys(sessionData).forEach((key) => delete sessionData[key]);
+      saveSession();
+    },
+    has(key) {
+      return key in sessionData;
+    },
+    flash(key, value) {
+      if (value !== void 0) {
+        flashData[key] = value;
+        return;
+      }
+      const val = flashData[key];
+      delete flashData[key];
+      return val;
+    },
+    regenerate() {
+      const oldId = sessionId;
+      sessionId = generateSessionId();
+      session.id = sessionId;
+      store.delete(oldId);
+      saveSession();
+    },
+    destroy() {
+      store.delete(sessionId);
+      Object.keys(sessionData).forEach((key) => delete sessionData[key]);
+    }
+  };
+  function saveSession() {
+    store.set(sessionId, { ...sessionData, __flash: flashData }, ttl);
+  }
+  saveSession();
+  return session;
+}
+function generateSessionId() {
+  return crypto.randomBytes(32).toString("hex");
+}
+function parseCookies(cookieHeader) {
+  if (!cookieHeader)
+    return {};
+  return cookieHeader.split(";").reduce((cookies, cookie) => {
+    const [name, ...valueParts] = cookie.trim().split("=");
+    if (name)
+      cookies[name] = decodeURIComponent(valueParts.join("="));
+    return cookies;
+  }, {});
+}
+function serializeCookie(name, value, options = {}) {
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  if (options.maxAge !== void 0)
+    cookie += `; Max-Age=${options.maxAge}`;
+  if (options.expires)
+    cookie += `; Expires=${options.expires.toUTCString()}`;
+  if (options.path)
+    cookie += `; Path=${options.path}`;
+  if (options.domain)
+    cookie += `; Domain=${options.domain}`;
+  if (options.secure)
+    cookie += "; Secure";
+  if (options.httpOnly)
+    cookie += "; HttpOnly";
+  if (options.sameSite)
+    cookie += `; SameSite=${options.sameSite}`;
+  return cookie;
+}
+function generateCsrfToken() {
+  return crypto.randomBytes(32).toString("hex");
+}
+function verifyCsrfToken(token, sessionToken) {
+  if (!token || !sessionToken)
+    return !1;
+  try {
+    return crypto.timingSafeEqual(Buffer.from(token), Buffer.from(sessionToken));
+  } catch {
+    return !1;
+  }
+}
+export async function render(template, data = {}, options = {}) {
+  const viewsDir = options.viewsDir || "./views", layoutsDir = options.layoutsDir || "./layouts", isPath = !template.includes("<") && !template.includes("@");
+  let templateContent, templatePath;
+  if (isPath) {
+    templatePath = path.resolve(viewsDir, template);
+    if (!templatePath.endsWith(".stx"))
+      templatePath += ".stx";
+    if (!await Bun.file(templatePath).exists())
+      return new Response(`Template not found: ${template}`, { status: 500 });
+    templateContent = await Bun.file(templatePath).text();
+  } else {
+    templateContent = template;
+    templatePath = "inline-template.stx";
+  }
+  const context = {
+    ...data,
+    props: data,
+    __filename: templatePath,
+    __dirname: path.dirname(templatePath)
+  };
+  if (options.ctx) {
+    context.csrf_token = options.ctx.csrfToken;
+    context.csrf_field = `<input type="hidden" name="_token" value="${options.ctx.csrfToken}">`;
+    context.old = options.ctx.old;
+    context.errors = options.ctx.errors;
+    context.session = options.ctx.session;
+    context.user = options.ctx.user();
+    context.isAuthenticated = options.ctx.isAuthenticated();
+  }
+  const serverScriptMatch = templateContent.match(/<script\s+server\b[^>]*>([\s\S]*?)<\/script>/i);
+  if (serverScriptMatch) {
+    const serverScript = serverScriptMatch[1];
+    templateContent = templateContent.replace(/<script\s+server\b[^>]*>[\s\S]*?<\/script>/gi, "");
+    await extractVariables(serverScript, context, templatePath);
+  }
+  const stxOptions = {
+    layoutsDir,
+    ...options.stxOptions
+  }, html = await processDirectives(templateContent, context, templatePath, stxOptions, new Set), headers = new Headers({
+    "Content-Type": "text/html; charset=utf-8"
+  });
+  if (options.ctx)
+    options.ctx.responseHeaders.forEach((value, key) => {
+      headers.set(key, value);
+    });
+  return new Response(html, { headers });
+}
+export function createApp(config = {}) {
+  const {
+    viewsDir = "./views",
+    layoutsDir = "./layouts",
+    defaultLayout,
+    sessionSecret = crypto.randomBytes(32).toString("hex"),
+    sessionCookieName = "stx_session",
+    sessionTtl = 86400,
+    stxOptions = {},
+    csrfCookieName = "csrf_token",
+    csrfEnabled = !0
+  } = config, store = config.sessionStore ?? new MemorySessionStore, routes = [], globalMiddleware = [];
+  function matchRoute(method, pathname) {
+    for (const route of routes) {
+      if (route.method !== method && route.method !== "*")
+        continue;
+      const paramNames = [], regexPattern = route.pattern.replace(/\/:(\w+)/g, (_, name) => {
+        paramNames.push(name);
+        return "/([^/]+)";
+      }).replace(/\//g, "\\/"), regex = new RegExp(`^${regexPattern}$`), match = pathname.match(regex);
+      if (match) {
+        const params = {};
+        paramNames.forEach((name, i) => {
+          params[name] = match[i + 1];
+        });
+        return { route, params };
+      }
+    }
+    return null;
+  }
+  async function createContext(request, params) {
+    const url = new URL(request.url), cookies = parseCookies(request.headers.get("Cookie")), responseHeaders = new Headers, cookiesToSet = [];
+    let sessionId = cookies[sessionCookieName];
+    if (!sessionId) {
+      sessionId = generateSessionId();
+      cookiesToSet.push(serializeCookie(sessionCookieName, sessionId, {
+        httpOnly: !0,
+        secure: url.protocol === "https:",
+        sameSite: "Lax",
+        path: "/",
+        maxAge: sessionTtl
+      }));
+    }
+    const session = await createSession(sessionId, sessionTtl, store);
+    let csrfToken = session.get("_csrf");
+    if (!csrfToken) {
+      csrfToken = generateCsrfToken();
+      session.set("_csrf", csrfToken);
+    }
+    const query = {};
+    url.searchParams.forEach((value, key) => {
+      query[key] = value;
+    });
+    const errors = session.flash("_errors") || {}, oldInput = session.flash("_old_input") || {}, ctx = {
+      request,
+      url,
+      params,
+      query,
+      session,
+      csrfToken,
+      cookies,
+      responseHeaders,
+      errors,
+      async formData() {
+        const formData = await request.formData(), data = {};
+        formData.forEach((value, key) => {
+          data[key] = value;
+        });
+        return data;
+      },
+      async json() {
+        return await request.json();
+      },
+      setCookie(name, value, options = {}) {
+        cookiesToSet.push(serializeCookie(name, value, options));
+      },
+      flash(key, value) {
+        session.flash(key, value);
+      },
+      getFlash(key) {
+        return session.flash(key);
+      },
+      old(key) {
+        return oldInput[key] || "";
+      },
+      isAuthenticated() {
+        return session.has("user");
+      },
+      user() {
+        return session.get("user");
+      }
+    };
+    if (cookiesToSet.length > 0)
+      cookiesToSet.forEach((cookie) => {
+        responseHeaders.append("Set-Cookie", cookie);
+      });
+    return ctx;
+  }
+  const csrfMiddleware = async (ctx, next) => {
+    if (["GET", "HEAD", "OPTIONS"].includes(ctx.request.method))
+      return next();
+    if (!csrfEnabled)
+      return next();
+    const tokenFromForm = (await ctx.request.clone().formData().catch(() => new FormData)).get("_token"), tokenFromHeader = ctx.request.headers.get("X-CSRF-Token"), token = tokenFromForm || tokenFromHeader, sessionToken = ctx.session.get("_csrf");
+    if (!token || !sessionToken || !verifyCsrfToken(token, sessionToken))
+      return new Response("CSRF token mismatch", { status: 419 });
+    return next();
+  };
+  async function fetch(request) {
+    const url = new URL(request.url), method = request.method, match = matchRoute(method, url.pathname);
+    if (!match)
+      return new Response("Not Found", { status: 404 });
+    const ctx = await createContext(request, match.params), middleware = [...globalMiddleware, csrfMiddleware, ...match.route.middleware];
+    let index = 0;
+    const next = async () => {
+      if (index < middleware.length) {
+        const mw = middleware[index++];
+        return mw(ctx, next);
+      }
+      return match.route.handler(ctx);
+    };
+    try {
+      const response = await next();
+      ctx.responseHeaders.forEach((value, key) => {
+        response.headers.set(key, value);
+      });
+      return response;
+    } catch (error) {
+      errorLogger.log(error instanceof Error ? error : Error(String(error)), { handler: "request" }, "error");
+      return new Response("Internal Server Error", { status: 500 });
+    }
+  }
+  function addRoute(method, pattern, handler, middleware = []) {
+    routes.push({ method, pattern, handler, middleware });
+  }
+  return {
+    fetch,
+    get(pattern, handler, middleware = []) {
+      addRoute("GET", pattern, handler, middleware);
+      return this;
+    },
+    post(pattern, handler, middleware = []) {
+      addRoute("POST", pattern, handler, middleware);
+      return this;
+    },
+    put(pattern, handler, middleware = []) {
+      addRoute("PUT", pattern, handler, middleware);
+      return this;
+    },
+    delete(pattern, handler, middleware = []) {
+      addRoute("DELETE", pattern, handler, middleware);
+      return this;
+    },
+    patch(pattern, handler, middleware = []) {
+      addRoute("PATCH", pattern, handler, middleware);
+      return this;
+    },
+    use(middleware) {
+      globalMiddleware.push(middleware);
+      return this;
+    },
+    async render(template, data = {}, ctx) {
+      return render(template, data, { viewsDir, layoutsDir, stxOptions, ctx });
+    },
+    redirect(url, status = 302) {
+      return new Response(null, {
+        status,
+        headers: { Location: url }
+      });
+    },
+    back(ctx, errors, oldInput) {
+      if (errors)
+        ctx.session.flash("_errors", errors);
+      if (oldInput)
+        ctx.session.flash("_old_input", oldInput);
+      const referer = ctx.request.headers.get("Referer") || "/";
+      return new Response(null, {
+        status: 302,
+        headers: { Location: referer }
+      });
+    },
+    listen(port = 3000) {
+      return Bun.serve({
+        port,
+        fetch
+      });
+    }
+  };
+}