elm-ssr 0.91.2 → 0.91.5

package/bin/elm-ssr.mjs

@@ -77,9 +77,9 @@ const printHelp = () => {
   compress      Pre-compress island and app bundles using Gzip for faster edge delivery
   dev           Build and start wrangler dev using the current workspace config
   init <name>   Initialize a self-contained single-app project in the current directory
-                (use --db to wire SQLite/migrations, --auth betterAuth|auth0 for auth guards)
+                (use --db to wire SQLite/migrations, --auth betterAuth|auth0 for auth guards, --tailwind for Tailwind CSS)
   new <name>    Create a new app at <workspace>/<name>/ and register it in elm-ssr.config.json
-                (use --in <subdir> to group, --db for SQLite, --auth betterAuth|auth0 for auth)
+                (use --in <subdir> to group, --db for SQLite, --auth betterAuth|auth0 for auth, --tailwind for Tailwind)
   routes        Print configured apps and their public modules
   route <path>  Scaffold a new route (standard HTML, --api JSON, --ws WebSocket, or --sse EventSource)
   query         Generate type-safe Elm Db modules from SQL table definitions
@@ -196,11 +196,12 @@ switch (command) {
     const name = args[1];
 
     if (!name) {
-      console.error("Usage: elm-ssr init <name> [--db] [--auth betterAuth|auth0]");
+      console.error("Usage: elm-ssr init <name> [--db] [--auth betterAuth|auth0] [--tailwind]");
       process.exit(1);
     }
 
     const db = args.includes("--db");
+    const tailwind = args.includes("--tailwind");
     let auth = findFlagValue("--auth");
     if (auth) {
       if (auth === "better-auth" || auth === "betterAuth") {
@@ -211,7 +212,7 @@ switch (command) {
       }
     }
 
-    const created = await createAppScaffold(rootPath, name, { root: ".", db, auth });
+    const created = await createAppScaffold(rootPath, name, { root: ".", db, auth, tailwind });
     console.log(`Initialized ${created.name} in current directory`);
     break;
   }
@@ -220,7 +221,7 @@ switch (command) {
     const name = args[1];
 
     if (!name) {
-      console.error("Usage: elm-ssr new <name> [--in <subdir>] [--db] [--auth betterAuth|auth0]");
+      console.error("Usage: elm-ssr new <name> [--in <subdir>] [--db] [--auth betterAuth|auth0] [--tailwind]");
       console.error("  Default location: <workspace>/<name>/");
       console.error("  Use --in apps to place it under <workspace>/apps/<name>/, etc.");
       process.exit(1);
@@ -230,6 +231,7 @@ switch (command) {
     const appRoot = subdir ? `${subdir.replace(/\/+$/, "")}/${name}` : name;
     
     const db = args.includes("--db");
+    const tailwind = args.includes("--tailwind");
     let auth = findFlagValue("--auth");
     if (auth) {
       if (auth === "better-auth" || auth === "betterAuth") {
@@ -240,7 +242,7 @@ switch (command) {
       }
     }
 
-    const created = await createAppScaffold(rootPath, name, { root: appRoot, db, auth });
+    const created = await createAppScaffold(rootPath, name, { root: appRoot, db, auth, tailwind });
     console.log(`Created ${created.name} at ${created.root}`);
     break;
   }

package/lib/scaffold.mjs

@@ -368,28 +368,57 @@ view user =
         }
 `;
 
-const authEndpointTemplate = (authProvider) => `export const handleAuth = async (request: Request, env: any): Promise<Response> => {
+const authEndpointTemplate = (authProvider) => `import { generateSessionId, signValue, generateCsrfToken, readSignedCookie } from "elm-ssr/sessions";
+
+export const handleAuth = async (
+  request: Request,
+  env: any,
+  options?: { store?: any; secret?: string }
+): Promise<Response> => {
   const url = new URL(request.url);
 
   if (url.pathname === "/api/auth/login") {
     // Mock login session update for ${authProvider}
+    let cookieVal = "__elm_ssr_session=" + encodeURIComponent(JSON.stringify({
+      user: { email: "user@example.com", name: "${authProvider === "better-auth" ? "BetterAuth User" : "Auth0 User"}" }
+    })) + "; Path=/; HttpOnly; SameSite=Lax";
+
+    if (options?.store && options?.secret) {
+      const sessionId = generateSessionId();
+      await options.store.set(sessionId, {
+        data: { email: "user@example.com", name: "${authProvider === "better-auth" ? "BetterAuth User" : "Auth0 User"}" },
+        csrf: generateCsrfToken()
+      });
+      const signed = await signValue(options.secret, sessionId);
+      cookieVal = "session=" + signed + "; Path=/; HttpOnly; SameSite=Lax";
+    }
+
     return new Response(null, {
       status: 302,
       headers: {
         "Location": "/profile",
-        "Set-Cookie": "__elm_ssr_session=" + encodeURIComponent(JSON.stringify({
-          user: { email: "user@example.com", name: "${authProvider === "better-auth" ? "BetterAuth User" : "Auth0 User"}" }
-        })) + "; Path=/; HttpOnly; SameSite=Lax"
+        "Set-Cookie": cookieVal
       }
     });
   }
 
   if (url.pathname === "/api/auth/logout") {
+    let cookieVal = "__elm_ssr_session=; Path=/; Max-Age=0; HttpOnly";
+    if (options?.store && options?.secret) {
+      cookieVal = "session=; Path=/; Max-Age=0; HttpOnly";
+      const cookieHeader = request.headers.get("cookie");
+      if (cookieHeader) {
+        const sessionId = await readSignedCookie(cookieHeader, "session", options.secret);
+        if (sessionId) {
+          await options.store.delete(sessionId);
+        }
+      }
+    }
     return new Response(null, {
       status: 302,
       headers: {
         "Location": "/login",
-        "Set-Cookie": "__elm_ssr_session=; Path=/; Max-Age=0; HttpOnly"
+        "Set-Cookie": cookieVal
       }
     });
   }
@@ -415,11 +444,10 @@ const runtimeTemplate = (appRoot, db = false, auth = undefined) => {
     `import ElmRuntime from "${generatedPrefix}/app.mjs";`
   ];
 
-  if (db) {
-    imports.push(`import { inMemoryEffects, cloudflareEffects } from "elm-ssr/effects";`);
-  }
+  imports.push(`import { inMemoryEffects, cloudflareEffects } from "elm-ssr/effects";`);
   if (auth) {
     imports.push(`import { handleAuth } from "./src/Endpoints/Auth";`);
+    imports.push(`import { memorySessionStore } from "elm-ssr/sessions";`);
   }
 
   let dbInit = '';
@@ -464,25 +492,24 @@ if (typeof Bun !== "undefined") {
     },`;
   }
 
-  let effectsConfig = '';
-  if (db) {
-    effectsConfig = `,
+  const effectsConfig = `,
   effects: (effect, context) => {
-    if (context.env && context.env.DB) {
-      return cloudflareEffects({ dbBinding: "DB" })(effect, context);
+    if (context.env) {
+      return cloudflareEffects(${db ? '{ dbBinding: "DB" }' : ''})(effect, context);
     }
     return inMemoryEffects({
-      env: process.env as any,
-      sql: sqlHandler
+      env: process.env as any${db ? ',\n      sql: sqlHandler' : ''}
     })(effect, context);
   }`;
-  }
 
   let sessionsConfig = '';
+  let authInit = '';
   if (auth) {
+    authInit = `\nexport const sessionStore = memorySessionStore();\n`;
     sessionsConfig = `,
   sessions: {
     secret: (env) => (env?.SESSION_SECRET as string) || "change-me-to-a-secure-random-hmac-secret-key-that-is-at-least-32-chars",
+    store: sessionStore,
     secure: false
   },
   csrf: true`;
@@ -496,7 +523,8 @@ const baseWorkerFetch = worker.fetch;
 worker.fetch = async (request, env, ctx) => {
   const url = new URL(request.url);
   if (url.pathname.startsWith("/api/auth/")) {
-    return handleAuth(request, env);
+    const secret = (env?.SESSION_SECRET as string) || "change-me-to-a-secure-random-hmac-secret-key-that-is-at-least-32-chars";
+    return handleAuth(request, env, { store: sessionStore, secret });
   }
   return baseWorkerFetch(request, env, ctx);
 };
@@ -586,7 +614,7 @@ export const createFlags = ({ request, path, formData, env }: { request?: Reques
 
 export const renderPath = async (path: string) =>
   renderApp(elmModule, createFlags({ path }));
-${dbInit}
+${dbInit}${authInit}
 export const worker = createWorkerApp({
   elmModule,
   islands,
@@ -667,6 +695,7 @@ const filesForApp = (name, appRoot, options = {}) => {
   const namespace = toPascalCase(name);
   const db = options.db || !!options.auth;
   const auth = options.auth;
+  const tailwind = options.tailwind;
 
   const files = [
     { path: `${appRoot}/elm.json`, content: JSON.stringify(elmJsonTemplate(), null, 2) + "\n" },
@@ -714,12 +743,27 @@ SESSION_SECRET="change-me-to-a-secure-random-hmac-secret-key-that-is-at-least-32
     });
   }
 
+  if (tailwind) {
+    files.push({
+      path: `${appRoot}/src/app.css`,
+      content: `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+`
+    });
+  }
+
+  const configEntry = {
+    name,
+    root: appRoot,
+    module: namespace
+  };
+  if (tailwind) {
+    configEntry.tailwind = true;
+  }
+
   return {
-    configEntry: {
-      name,
-      root: appRoot,
-      module: namespace
-    },
+    configEntry,
     files
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elm-ssr",
-  "version": "0.91.2",
+  "version": "0.91.5",
   "description": "Elm-first SSR library and framework for Cloudflare Workers (and Bun): file-based routes/islands, backend-neutral effect adapters (KV/D1/Redis/Postgres), background tasks (waitUntil/Queues), SQL-file migrations, CLI scaffold + build.",
   "license": "MIT",
   "author": "Michał Majchrzak <michmajchrzak@gmail.com>",

package/src/app.ts

@@ -1,4 +1,5 @@
 import type {
+  Middleware,
   RenderFlagsFactory,
   RouteCatalog,
   WorkerExecutionContext,
@@ -50,6 +51,7 @@ export interface WorkerAppOptions {
    * skip paths.
    */
   csrf?: CsrfMiddlewareOptions | boolean;
+  middlewares?: Middleware[];
   debug?: boolean;
 }
 
@@ -64,6 +66,7 @@ export const createWorkerApp = ({
   log,
   sessions,
   csrf,
+  middlewares,
   debug
 }: WorkerAppOptions): WorkerHandler => {
   const isDev = typeof process !== "undefined" && process.env ? (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") : false;
@@ -83,21 +86,24 @@ export const createWorkerApp = ({
     debug: enableDebug
   });
 
-  const middlewares = [
+  const middlewaresList = [
     errorMiddleware,
     requestIdMiddleware,
     timingMiddleware,
     loggingMiddleware(log)
   ];
   if (sessions) {
-    middlewares.push(sessionMiddleware(sessions));
+    middlewaresList.push(sessionMiddleware(sessions));
     if (csrf) {
-      middlewares.push(csrfMiddleware(csrf === true ? {} : csrf));
+      middlewaresList.push(csrfMiddleware(csrf === true ? {} : csrf));
     }
   }
-  middlewares.push(headMiddleware);
+  if (middlewares) {
+    middlewaresList.push(...middlewares);
+  }
+  middlewaresList.push(headMiddleware);
 
-  const appHandler = composeMiddleware(handler, middlewares);
+  const appHandler = composeMiddleware(handler, middlewaresList);
 
   return {
     fetch(request: Request, env?: unknown, executionCtx?: WorkerExecutionContext) {

package/src/sessions/index.ts

@@ -6,6 +6,7 @@ export { memorySessionStore, cacheStore, type CacheStoreOptions } from "./store"
 export {
   sessionMiddleware,
   csrfMiddleware,
+  readSignedCookie,
   type SessionMiddlewareOptions,
   type CsrfMiddlewareOptions
 } from "./middleware";

package/src/sessions/middleware.ts

@@ -50,7 +50,7 @@ const appendSetCookie = (response: Response, header: string): Response => {
   });
 };
 
-const readSignedCookie = async (header: string | null, name: string, secret: string): Promise<string | null> => {
+export const readSignedCookie = async (header: string | null, name: string, secret: string): Promise<string | null> => {
   if (!header) {
     return null;
   }
@@ -104,14 +104,21 @@ export const sessionMiddleware = (options: SessionMiddlewareOptions): Middleware
     if (sessionId) {
       const existing = await options.store.get(sessionId);
       if (existing) {
-        session = {
-          id: sessionId,
-          data: existing.data,
-          csrf: existing.csrf,
-          dirty: false,
-          destroyed: false,
-          isNew: false
-        };
+        if (existing.expiresAt && Date.now() > existing.expiresAt) {
+          // Session expired
+          await options.store.delete(sessionId);
+          session = mintSession();
+          session.destroyed = true; // Ensure the cookie gets cleared as well
+        } else {
+          session = {
+            id: sessionId,
+            data: existing.data,
+            csrf: existing.csrf,
+            dirty: false,
+            destroyed: false,
+            isNew: false
+          };
+        }
       } else {
         session = mintSession();
       }

package/src/sessions/store.ts

@@ -2,9 +2,10 @@ import type { CacheBackend } from "../backends";
 import type { SessionRecord, SessionStore } from "./types";
 
 /** In-memory session store. Survives only as long as the process. */
-export const memorySessionStore = (initial?: Map<string, SessionRecord>): SessionStore => {
+export const memorySessionStore = (initial?: Map<string, SessionRecord>): SessionStore & { store: Map<string, SessionRecord> } => {
   const store = initial ?? new Map<string, SessionRecord>();
   return {
+    store,
     get: async (id) => {
       const record = store.get(id);
       if (!record) {