@batijs/cli 0.0.244 → 0.0.245

package/dist/boilerplates/@batijs/h3/files/h3-entry.ts

@@ -10,9 +10,10 @@ import {
   firebaseAuthMiddleware,
 } from "@batijs/firebase-auth/server/firebase-auth-middleware";
 import {
+  luciaAuthContextMiddleware,
+  luciaAuthCookieMiddleware,
   luciaAuthLoginHandler,
   luciaAuthLogoutHandler,
-  luciaAuthMiddleware,
   luciaAuthSignupHandler,
   luciaCsrfMiddleware,
   luciaGithubCallbackHandler,
@@ -27,8 +28,9 @@ import installCrypto from "@hattip/polyfills/crypto";
 import installGetSetCookie from "@hattip/polyfills/get-set-cookie";
 import installWhatwgNodeFetch from "@hattip/polyfills/whatwg-node";
 import { type NodeHTTPCreateContextFnOptions, nodeHTTPRequestHandler } from "@trpc/server/adapters/node-http";
-import { createApp, createRouter, eventHandler, fromNodeMiddleware, toNodeListener, toWebRequest } from "h3";
+import { createApp, createRouter, eventHandler, fromNodeMiddleware, toNodeListener } from "h3";
 import serveStatic from "serve-static";
+import { createHandler, createMiddleware } from "@universal-middleware/h3";
 
 installWhatwgNodeFetch();
 installGetSetCookie();
@@ -40,20 +42,6 @@ const root = __dirname;
 const port = process.env.PORT ? parseInt(process.env.PORT, 10) : 3000;
 const hmrPort = process.env.HMR_PORT ? parseInt(process.env.HMR_PORT, 10) : 24678;
 
-interface Middleware<Context extends Record<string | number | symbol, unknown>> {
-  (request: Request, context: Context): Response | void | Promise<Response> | Promise<void>;
-}
-
-export function fromWebMiddleware<Context extends Record<string | number | symbol, unknown>>(
-  handler: Middleware<Context>,
-) {
-  return eventHandler((event) => {
-    const ctx = event.context as unknown as Record<string, unknown>;
-    ctx.context ??= {};
-    return handler(toWebRequest(event), ctx.context as Context);
-  });
-}
-
 export default await startServer();
 
 async function startServer() {
@@ -81,30 +69,31 @@ async function startServer() {
     /**
      * Append Auth.js session to context
      **/
-    app.use(fromWebMiddleware(authjsSessionMiddleware));
+    app.use(createMiddleware(authjsSessionMiddleware)());
 
     /**
      * Auth.js route
      * @link {@see https://authjs.dev/getting-started/installation}
      **/
-    router.use("/api/auth/**", fromWebMiddleware(authjsHandler));
+    router.use("/api/auth/**", createHandler(authjsHandler)());
   }
 
   if (BATI.has("firebase-auth")) {
-    app.use(fromWebMiddleware(firebaseAuthMiddleware));
-    router.post("/api/sessionLogin", fromWebMiddleware(firebaseAuthLoginHandler));
-    router.post("/api/sessionLogout", fromWebMiddleware(firebaseAuthLogoutHandler));
+    app.use(createMiddleware(firebaseAuthMiddleware)());
+    router.post("/api/sessionLogin", createHandler(firebaseAuthLoginHandler)());
+    router.post("/api/sessionLogout", createHandler(firebaseAuthLogoutHandler)());
   }
 
   if (BATI.has("lucia-auth")) {
-    app.use(fromWebMiddleware(luciaCsrfMiddleware));
-    app.use(fromWebMiddleware(luciaAuthMiddleware));
-
-    router.post("/api/signup", fromWebMiddleware(luciaAuthSignupHandler));
-    router.post("/api/login", fromWebMiddleware(luciaAuthLoginHandler));
-    router.post("/api/logout", fromWebMiddleware(luciaAuthLogoutHandler));
-    router.get("/api/login/github", fromWebMiddleware(luciaGithubLoginHandler));
-    router.get("/api/login/github/callback", fromWebMiddleware(luciaGithubCallbackHandler));
+    app.use(createMiddleware(luciaCsrfMiddleware)());
+    app.use(createMiddleware(luciaAuthContextMiddleware)());
+    app.use(createMiddleware(luciaAuthCookieMiddleware)());
+
+    router.post("/api/signup", createHandler(luciaAuthSignupHandler)());
+    router.post("/api/login", createHandler(luciaAuthLoginHandler)());
+    router.post("/api/logout", createHandler(luciaAuthLogoutHandler)());
+    router.get("/api/login/github", createHandler(luciaGithubLoginHandler)());
+    router.get("/api/login/github/callback", createHandler(luciaGithubCallbackHandler)());
   }
 
   if (BATI.has("trpc")) {
@@ -135,15 +124,15 @@ async function startServer() {
      *
      * @link {@see https://telefunc.com}
      **/
-    router.post("/_telefunc", fromWebMiddleware(telefuncHandler));
+    router.post("/_telefunc", createHandler(telefuncHandler)());
   }
 
   if (BATI.has("ts-rest")) {
-    router.use("/api/**", fromWebMiddleware(tsRestHandler));
+    router.use("/api/**", createHandler(tsRestHandler)());
   }
 
   if (!BATI.has("telefunc") && !BATI.has("trpc") && !BATI.has("ts-rest")) {
-    router.post("/api/todo/create", fromWebMiddleware(createTodoHandler));
+    router.post("/api/todo/create", createHandler(createTodoHandler)());
   }
 
   /**
@@ -151,7 +140,7 @@ async function startServer() {
    *
    * @link {@see https://vike.dev}
    **/
-  router.use("/**", fromWebMiddleware(vikeHandler));
+  router.use("/**", createHandler(vikeHandler)());
 
   app.use(router);
 

package/dist/boilerplates/@batijs/h3/types/h3-entry.d.ts

@@ -1,8 +1,4 @@
 import "dotenv/config";
 import { type IncomingMessage, type ServerResponse } from "node:http";
-interface Middleware<Context extends Record<string | number | symbol, unknown>> {
-    (request: Request, context: Context): Response | void | Promise<Response> | Promise<void>;
-}
-export declare function fromWebMiddleware<Context extends Record<string | number | symbol, unknown>>(handler: Middleware<Context>): import("h3").EventHandler<import("h3").EventHandlerRequest, void | Response | Promise<Response> | Promise<void>>;
 declare const _default: import("http").Server<typeof IncomingMessage, typeof ServerResponse>;
 export default _default;

package/dist/boilerplates/@batijs/hattip/files/$package.json.js

@@ -58,12 +58,13 @@ var require_package = __commonJS({
         "@hattip/vite": "^0.0.47",
         "@trpc/server": "^10.45.2",
         "@types/node": "^18.19.14",
+        "@universal-middleware/hattip": "^0.2.1",
         "cross-env": "^7.0.3",
         dotenv: "^16.4.5",
         hattip: "^0.0.33",
         telefunc: "^0.1.76",
-        vike: "^0.4.183",
-        vite: "^5.4.0"
+        vike: "^0.4.187",
+        vite: "^5.4.1"
       },
       dependencies: {
         "@batijs/core": "workspace:*"
@@ -132,7 +133,7 @@ async function getPackageJson(props) {
       "hattip",
       "vite",
       "vike",
-      ...props.meta.BATI.has("authjs") || props.meta.BATI.has("auth0") ? ["@auth/core", "dotenv"] : [],
+      "@universal-middleware/hattip",
       ...props.meta.BATI.has("vercel") ? ["@hattip/adapter-vercel-edge"] : []
     ]
   });

package/dist/boilerplates/@batijs/hattip/files/hattip-entry.ts

@@ -7,9 +7,10 @@ import {
   firebaseAuthMiddleware,
 } from "@batijs/firebase-auth/server/firebase-auth-middleware";
 import {
+  luciaAuthContextMiddleware,
+  luciaAuthCookieMiddleware,
   luciaAuthLoginHandler,
   luciaAuthLogoutHandler,
-  luciaAuthMiddleware,
   luciaAuthSignupHandler,
   luciaCsrfMiddleware,
   luciaGithubCallbackHandler,
@@ -21,23 +22,10 @@ import { telefuncHandler } from "@batijs/telefunc/server/telefunc-handler";
 import { appRouter } from "@batijs/trpc/trpc/server";
 import { tsRestHandler } from "@batijs/ts-rest/server/ts-rest-handler";
 import type { HattipHandler } from "@hattip/core";
-import { createRouter, type RouteHandler } from "@hattip/router";
+import { createRouter } from "@hattip/router";
 import { fetchRequestHandler } from "@trpc/server/adapters/fetch";
 import vercelAdapter from "@hattip/adapter-vercel-edge";
-
-interface Middleware<Context extends Record<string | number | symbol, unknown>> {
-  (request: Request, context: Context): Response | void | Promise<Response> | Promise<void>;
-}
-
-function handlerAdapter<Context extends Record<string | number | symbol, unknown>>(
-  handler: Middleware<Context>,
-): RouteHandler<unknown, unknown> {
-  return (context) => {
-    const rawContext = context as unknown as Record<string, unknown>;
-    rawContext.context ??= {};
-    return handler(context.request, rawContext.context as Context);
-  };
-}
+import { createHandler, createMiddleware } from "@universal-middleware/hattip";
 
 const router = createRouter();
 
@@ -47,7 +35,7 @@ if (BATI.has("telefunc")) {
    *
    * @link {@see https://telefunc.com}
    **/
-  router.post("/_telefunc", handlerAdapter(telefuncHandler));
+  router.post("/_telefunc", createHandler(telefuncHandler)());
 }
 
 if (BATI.has("trpc")) {
@@ -69,41 +57,42 @@ if (BATI.has("trpc")) {
 }
 
 if (BATI.has("ts-rest")) {
-  router.use("/api/*", handlerAdapter(tsRestHandler));
+  router.use("/api/*", createMiddleware(tsRestHandler)());
 }
 
 if (BATI.has("authjs") || BATI.has("auth0")) {
   /**
    * Append Auth.js session to context
    **/
-  router.use(handlerAdapter(authjsSessionMiddleware));
+  router.use(createMiddleware(authjsSessionMiddleware)());
 
   /**
    * Auth.js route
    * @link {@see https://authjs.dev/getting-started/installation}
    **/
-  router.use("/api/auth/*", handlerAdapter(authjsHandler));
+  router.use("/api/auth/*", createHandler(authjsHandler)());
 }
 
 if (BATI.has("firebase-auth")) {
-  router.use(handlerAdapter(firebaseAuthMiddleware));
-  router.post("/api/sessionLogin", handlerAdapter(firebaseAuthLoginHandler));
-  router.post("/api/sessionLogout", handlerAdapter(firebaseAuthLogoutHandler));
+  router.use(createMiddleware(firebaseAuthMiddleware)());
+  router.post("/api/sessionLogin", createHandler(firebaseAuthLoginHandler)());
+  router.post("/api/sessionLogout", createHandler(firebaseAuthLogoutHandler)());
 }
 
 if (BATI.has("lucia-auth")) {
-  router.use(handlerAdapter(luciaCsrfMiddleware));
-  router.use(handlerAdapter(luciaAuthMiddleware));
-
-  router.post("/api/signup", handlerAdapter(luciaAuthSignupHandler));
-  router.post("/api/login", handlerAdapter(luciaAuthLoginHandler));
-  router.post("/api/logout", handlerAdapter(luciaAuthLogoutHandler));
-  router.get("/api/login/github", handlerAdapter(luciaGithubLoginHandler));
-  router.get("/api/login/github/callback", handlerAdapter(luciaGithubCallbackHandler));
+  router.use(createMiddleware(luciaCsrfMiddleware)());
+  router.use(createMiddleware(luciaAuthContextMiddleware)());
+  router.use(createMiddleware(luciaAuthCookieMiddleware)());
+
+  router.post("/api/signup", createHandler(luciaAuthSignupHandler)());
+  router.post("/api/login", createHandler(luciaAuthLoginHandler)());
+  router.post("/api/logout", createHandler(luciaAuthLogoutHandler)());
+  router.get("/api/login/github", createHandler(luciaGithubLoginHandler)());
+  router.get("/api/login/github/callback", createHandler(luciaGithubCallbackHandler)());
 }
 
 if (!BATI.has("telefunc") && !BATI.has("trpc") && !BATI.has("ts-rest")) {
-  router.post("/api/todo/create", handlerAdapter(createTodoHandler));
+  router.post("/api/todo/create", createHandler(createTodoHandler)());
 }
 
 /**
@@ -111,7 +100,7 @@ if (!BATI.has("telefunc") && !BATI.has("trpc") && !BATI.has("ts-rest")) {
  *
  * @link {@see https://vike.dev}
  **/
-router.use(handlerAdapter(vikeHandler));
+router.use(createHandler(vikeHandler)());
 
 const handler: HattipHandler = router.buildHandler();
 

package/dist/boilerplates/@batijs/hono/files/$package.json.js

@@ -51,18 +51,18 @@ var require_package = __commonJS({
         "@batijs/telefunc": "workspace:^",
         "@batijs/trpc": "workspace:^",
         "@batijs/ts-rest": "workspace:*",
-        "@hono/node-server": "^1.12.0",
+        "@hono/node-server": "^1.12.1",
         "@hono/vite-dev-server": "^0.14.0",
         "@trpc/server": "^10.45.2",
         "@types/node": "^18.19.14",
-        "@universal-middleware/hono": "^0.1.1",
+        "@universal-middleware/hono": "^0.2.1",
         "cross-env": "^7.0.3",
         dotenv: "^16.4.5",
-        hono: "^4.5.5",
+        hono: "^4.5.6",
         telefunc: "^0.1.76",
         tsx: "^4.17.0",
-        vike: "^0.4.183",
-        vite: "^5.4.0"
+        vike: "^0.4.187",
+        vite: "^5.4.1"
       },
       dependencies: {
         "@batijs/core": "workspace:*"
@@ -119,16 +119,7 @@ async function getPackageJson(props) {
   });
   return addDependency(packageJson, await Promise.resolve().then(() => __toESM(require_package(), 1)).then((x) => x.default), {
     devDependencies: ["@hono/vite-dev-server", "@types/node"],
-    dependencies: [
-      "@hono/node-server",
-      "@universal-middleware/hono",
-      "cross-env",
-      "hono",
-      "tsx",
-      "vite",
-      "vike",
-      ...props.meta.BATI.has("authjs") || props.meta.BATI.has("auth0") ? ["@auth/core", "dotenv"] : []
-    ]
+    dependencies: ["@hono/node-server", "@universal-middleware/hono", "cross-env", "hono", "tsx", "vite", "vike"]
   });
 }
 export {

package/dist/boilerplates/@batijs/hono/files/hono-entry.ts

@@ -7,9 +7,10 @@ import {
   firebaseAuthMiddleware,
 } from "@batijs/firebase-auth/server/firebase-auth-middleware";
 import {
+  luciaAuthContextMiddleware,
+  luciaAuthCookieMiddleware,
   luciaAuthLoginHandler,
   luciaAuthLogoutHandler,
-  luciaAuthMiddleware,
   luciaAuthSignupHandler,
   luciaCsrfMiddleware,
   luciaGithubCallbackHandler,
@@ -31,30 +32,31 @@ if (BATI.has("authjs") || BATI.has("auth0")) {
   /**
    * Append Auth.js session to context
    **/
-  app.use(createMiddleware(authjsSessionMiddleware));
+  app.use(createMiddleware(authjsSessionMiddleware)());
 
   /**
    * Auth.js route
    * @link {@see https://authjs.dev/getting-started/installation}
    **/
-  app.use("/api/auth/**", createHandler(authjsHandler));
+  app.use("/api/auth/**", createHandler(authjsHandler)());
 }
 
 if (BATI.has("firebase-auth")) {
-  app.use(createMiddleware(firebaseAuthMiddleware));
-  app.post("/api/sessionLogin", createHandler(firebaseAuthLoginHandler));
-  app.post("/api/sessionLogout", createHandler(firebaseAuthLogoutHandler));
+  app.use(createMiddleware(firebaseAuthMiddleware)());
+  app.post("/api/sessionLogin", createHandler(firebaseAuthLoginHandler)());
+  app.post("/api/sessionLogout", createHandler(firebaseAuthLogoutHandler)());
 }
 
 if (BATI.has("lucia-auth")) {
-  app.use(createMiddleware(luciaCsrfMiddleware));
-  app.use(createMiddleware(luciaAuthMiddleware));
+  app.use(createMiddleware(luciaCsrfMiddleware)());
+  app.use(createMiddleware(luciaAuthContextMiddleware)());
+  app.use(createMiddleware(luciaAuthCookieMiddleware)());
 
-  app.post("/api/signup", createHandler(luciaAuthSignupHandler));
-  app.post("/api/login", createHandler(luciaAuthLoginHandler));
-  app.post("/api/logout", createHandler(luciaAuthLogoutHandler));
-  app.get("/api/login/github", createHandler(luciaGithubLoginHandler));
-  app.get("/api/login/github/callback", createHandler(luciaGithubCallbackHandler));
+  app.post("/api/signup", createHandler(luciaAuthSignupHandler)());
+  app.post("/api/login", createHandler(luciaAuthLoginHandler)());
+  app.post("/api/logout", createHandler(luciaAuthLogoutHandler)());
+  app.get("/api/login/github", createHandler(luciaGithubLoginHandler)());
+  app.get("/api/login/github/callback", createHandler(luciaGithubCallbackHandler)());
 }
 
 if (BATI.has("trpc")) {
@@ -81,15 +83,15 @@ if (BATI.has("telefunc")) {
    *
    * @link {@see https://telefunc.com}
    **/
-  app.post("/_telefunc", createHandler(telefuncHandler));
+  app.post("/_telefunc", createHandler(telefuncHandler)());
 }
 
 if (BATI.has("ts-rest")) {
-  app.all("/api/*", createHandler(tsRestHandler));
+  app.all("/api/*", createHandler(tsRestHandler)());
 }
 
 if (!BATI.has("telefunc") && !BATI.has("trpc") && !BATI.has("ts-rest")) {
-  app.post("/api/todo/create", createHandler(createTodoHandler));
+  app.post("/api/todo/create", createHandler(createTodoHandler)());
 }
 
 /**
@@ -97,7 +99,7 @@ if (!BATI.has("telefunc") && !BATI.has("trpc") && !BATI.has("ts-rest")) {
  *
  * @link {@see https://vike.dev}
  **/
-app.all("*", createHandler(vikeHandler));
+app.all("*", createHandler(vikeHandler)());
 
 //# BATI.has("vercel")
 export const GET = handle(app);

package/dist/boilerplates/@batijs/lucia-auth/files/$package.json.js

@@ -48,14 +48,15 @@ var require_package = __commonJS({
         "@types/better-sqlite3": "^7.6.11",
         "@types/cookie": "^0.6.0",
         "@types/node": "^18.19.14",
+        "@universal-middleware/core": "^0.2.3",
         arctic: "^1.9.2",
         "better-sqlite3": "^11.1.2",
         cookie: "^0.6.0",
         dotenv: "^16.4.5",
         "drizzle-orm": "^0.33.0",
         lucia: "^3.2.0",
-        vike: "^0.4.183",
-        vite: "^5.4.0"
+        vike: "^0.4.187",
+        vite: "^5.4.1"
       },
       dependencies: {
         "@batijs/core": "workspace:*"
@@ -124,6 +125,7 @@ async function getPackageJson(props) {
       "arctic",
       "cookie",
       "lucia",
+      "@universal-middleware/core",
       ...props.meta.BATI.has("drizzle") ? ["@lucia-auth/adapter-drizzle"] : ["better-sqlite3", "@lucia-auth/adapter-sqlite"]
     ]
   });

package/dist/boilerplates/@batijs/lucia-auth/files/server/lucia-auth-handlers.ts

@@ -9,16 +9,14 @@ import { parse, serialize } from "cookie";
 import { drizzleDb } from "@batijs/drizzle/database/drizzleDb";
 import { oauthAccountTable, userTable } from "../database/schema/auth";
 import { getExistingAccount, getExistingUser, validateInput } from "../database/auth-actions";
+import type { Get, UniversalHandler, UniversalMiddleware } from "@universal-middleware/core";
 
 /**
  * CSRF protection middleware
  *
  * @link {@see https://lucia-auth.com/guides/validate-session-cookies/}
  */
-export function luciaCsrfMiddleware<Context extends Record<string | number | symbol, unknown>>(
-  request: Request,
-  _context?: Context,
-): Response | undefined {
+export const luciaCsrfMiddleware = (() => async (request) => {
   if (request.method === "GET") {
     return;
   }
@@ -32,46 +30,56 @@ export function luciaCsrfMiddleware<Context extends Record<string | number | sym
       });
     }
   }
-}
+}) satisfies Get<[], UniversalMiddleware>;
 
 /**
- * Validate session cookies middleware
+ * Validate session cookies middleware and set context
  *
  * @link {@see https://lucia-auth.com/guides/validate-session-cookies/}
  */
-export async function luciaAuthMiddleware<Context extends Record<string | number | symbol, unknown>>(
-  request: Request,
-  context: Context & { session?: Session | null; user?: User | null },
-): Promise<void> {
+export const luciaAuthContextMiddleware = (() => async (request, context) => {
   const sessionId = lucia.readSessionCookie(request.headers.get("cookie") ?? "");
 
   if (!sessionId) {
-    context.user = null;
-    context.session = null;
+    return {
+      ...context,
+      session: null,
+      user: null,
+    };
   } else {
     const { session, user } = await lucia.validateSession(sessionId);
 
-    if (session?.fresh) {
-      request.headers.append("Set-Cookie", lucia.createSessionCookie(session.id).serialize());
+    return {
+      ...context,
+      sessionId,
+      session,
+      user,
+    };
+  }
+}) satisfies Get<[], UniversalMiddleware>;
+
+/**
+ * Set Set-Cookie headers if in context
+ */
+export const luciaAuthCookieMiddleware = (() => (_request, context) => {
+  return (response: Response) => {
+    if (context.session?.fresh) {
+      response.headers.append("Set-Cookie", lucia.createSessionCookie(context.session.id).serialize());
     }
-    if (!session) {
-      request.headers.append("Set-Cookie", lucia.createBlankSessionCookie().serialize());
+    if (context.sessionId && !context.session) {
+      response.headers.append("Set-Cookie", lucia.createBlankSessionCookie().serialize());
     }
 
-    context.session = session;
-    context.user = user;
-  }
-}
+    return response;
+  };
+}) satisfies Get<[], UniversalMiddleware<{ session?: Session | null; user?: User | null; sessionId?: string | null }>>;
 
 /**
  * Register user handler
  *
  * @link {@see https://lucia-auth.com/guides/email-and-password/basics#register-user}
  */
-export async function luciaAuthSignupHandler<Context extends Record<string | number | symbol, unknown>>(
-  request: Request,
-  _context?: Context,
-): Promise<Response> {
+export const luciaAuthSignupHandler = (() => async (request) => {
   const body = (await request.json()) as { username: string; password: string };
   const username = body.username ?? "";
   const password = body.password ?? "";
@@ -134,17 +142,14 @@ export async function luciaAuthSignupHandler<Context extends Record<string | num
       },
     });
   }
-}
+}) satisfies Get<[], UniversalMiddleware>;
 
 /**
  * Sign in user handler
  *
  * @link {@see https://lucia-auth.com/guides/email-and-password/basics#sign-in-user}
  */
-export async function luciaAuthLoginHandler<Context extends Record<string | number | symbol, unknown>>(
-  request: Request,
-  _context?: Context,
-): Promise<Response> {
+export const luciaAuthLoginHandler = (() => async (request) => {
   const body = (await request.json()) as { username: string; password: string };
   const username = body.username ?? "";
   const password = body.password ?? "";
@@ -191,15 +196,12 @@ export async function luciaAuthLoginHandler<Context extends Record<string | numb
       "set-cookie": lucia.createSessionCookie(session.id).serialize(),
     },
   });
-}
+}) satisfies Get<[], UniversalMiddleware>;
 
 /**
  * Log out user handler
  */
-export async function luciaAuthLogoutHandler<Context extends Record<string | number | symbol, unknown>>(
-  _request: Request,
-  context: Context & { session?: Session | null },
-): Promise<Response> {
+export const luciaAuthLogoutHandler = (() => async (_request, context) => {
   const session = context.session ?? null;
 
   if (!session) {
@@ -225,17 +227,14 @@ export async function luciaAuthLogoutHandler<Context extends Record<string | num
       "set-cookie": lucia.createBlankSessionCookie().serialize(),
     },
   });
-}
+}) satisfies Get<[], UniversalMiddleware<{ session?: Session | null }>>;
 
 /**
  * Github OAuth authorization handler
  *
  * @link {@see https://lucia-auth.com/guides/oauth/basics#creating-authorization-url}
  */
-export async function luciaGithubLoginHandler<Context extends Record<string | number | symbol, unknown>>(
-  _request: Request,
-  _context?: Context,
-): Promise<Response> {
+export const luciaGithubLoginHandler = (() => async () => {
   const state = generateState();
   const url = await github.createAuthorizationURL(state);
 
@@ -252,17 +251,14 @@ export async function luciaGithubLoginHandler<Context extends Record<string | nu
       }),
     },
   });
-}
+}) satisfies Get<[], UniversalHandler>;
 
 /**
  * Github OAuth validate callback handler
  *
  * @link {@see https://lucia-auth.com/guides/oauth/basics#validate-callback}
  */
-export async function luciaGithubCallbackHandler<Context extends Record<string | number | symbol, unknown>>(
-  request: Request,
-  _context?: Context,
-): Promise<Response> {
+export const luciaGithubCallbackHandler = (() => async (request) => {
   const cookies = parse(request.headers.get("cookie") ?? "");
   const params = new URL(request.url).searchParams;
   const code = params.get("code");
@@ -341,4 +337,4 @@ export async function luciaGithubCallbackHandler<Context extends Record<string |
       },
     });
   }
-}
+}) satisfies Get<[], UniversalHandler>;