@batijs/cli 0.0.259 → 0.0.261

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

@@ -13,21 +13,29 @@ import {
   luciaAuthLogoutHandler,
   luciaAuthSignupHandler,
   luciaCsrfMiddleware,
+  luciaDbMiddleware,
   luciaGithubCallbackHandler,
   luciaGithubLoginHandler,
 } from "@batijs/lucia-auth/server/lucia-auth-handlers";
 import { createTodoHandler } from "@batijs/shared-server/server/create-todo-handler";
 import { vikeHandler } from "@batijs/shared-server/server/vike-handler";
 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 FetchCreateContextFnOptions, fetchRequestHandler } from "@trpc/server/adapters/fetch";
 import { Hono } from "hono";
 import { handle } from "hono/vercel";
 import { createHandler, createMiddleware } from "@universal-middleware/hono";
+import { dbMiddleware } from "@batijs/shared-db/server/db-middleware";
+import { trpcHandler } from "@batijs/trpc/server/trpc-handler";
 
 const app = new Hono();
 
+if (BATI.hasDatabase) {
+  /**
+   * Make database available in Context as `context.db`
+   */
+  app.use(createMiddleware(dbMiddleware)());
+}
+
 if (BATI.has("authjs") || BATI.has("auth0")) {
   /**
    * Append Auth.js session to context
@@ -48,6 +56,7 @@ if (BATI.has("firebase-auth")) {
 }
 
 if (BATI.has("lucia-auth")) {
+  app.use(createMiddleware(luciaDbMiddleware)());
   app.use(createMiddleware(luciaCsrfMiddleware)());
   app.use(createMiddleware(luciaAuthContextMiddleware)());
   app.use(createMiddleware(luciaAuthCookieMiddleware)());
@@ -65,16 +74,7 @@ if (BATI.has("trpc")) {
    *
    * @link {@see https://trpc.io/docs/server/adapters}
    **/
-  app.use("/api/trpc/*", (c) => {
-    return fetchRequestHandler({
-      endpoint: "/api/trpc",
-      req: c.req.raw,
-      router: appRouter,
-      createContext({ req, resHeaders }): FetchCreateContextFnOptions {
-        return { req, resHeaders };
-      },
-    });
-  });
+  app.use("/api/trpc/*", createHandler(trpcHandler)("/api/trpc"));
 }
 
 if (BATI.has("telefunc")) {

package/dist/boilerplates/@batijs/hono/types/entry_aws_lambda.d.ts

@@ -0,0 +1,3 @@
+import type { LambdaEvent } from "hono/aws-lambda";
+import type { Handler, APIGatewayProxyResult } from "aws-lambda";
+export declare const handler: Handler<LambdaEvent, APIGatewayProxyResult>;

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

@@ -43,13 +43,16 @@ var require_package = __commonJS({
       devDependencies: {
         "@batijs/compile": "workspace:*",
         "@batijs/drizzle": "workspace:*",
+        "@batijs/d1": "workspace:*",
+        "@batijs/d1-sqlite": "workspace:*",
         "@batijs/sqlite": "workspace:*",
+        "@cloudflare/workers-types": "^4.20240821.1",
         "@lucia-auth/adapter-drizzle": "^1.1.0",
         "@lucia-auth/adapter-sqlite": "^3.0.2",
         "@types/better-sqlite3": "^7.6.11",
         "@types/cookie": "^0.6.0",
         "@types/node": "^18.19.14",
-        "@universal-middleware/core": "^0.2.5",
+        "@universal-middleware/core": "^0.2.6",
         arctic: "^1.9.2",
         "better-sqlite3": "^11.2.1",
         cookie: "^0.6.0",

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

@@ -1,11 +1,12 @@
 import "dotenv/config";
-import { Lucia } from "lucia";
-import { BetterSqlite3Adapter } from "@lucia-auth/adapter-sqlite";
+import { Lucia, type Register } from "lucia";
+import { BetterSqlite3Adapter, D1Adapter } from "@lucia-auth/adapter-sqlite";
 import { GitHub } from "arctic";
 import { DrizzleSQLiteAdapter } from "@lucia-auth/adapter-drizzle";
-import { db as drizzleDb } from "@batijs/drizzle/database/drizzle/db";
-import { sessionTable, userTable } from "@batijs/drizzle/database/drizzle/schema/lucia-auth";
+import { dbD1, dbSqlite } from "@batijs/drizzle/database/drizzle/db";
 import { db as sqliteDb } from "@batijs/sqlite/database/sqlite/db";
+import { sessionTable, userTable } from "@batijs/drizzle/database/drizzle/schema/lucia-auth";
+import { D1Database } from "@cloudflare/workers-types";
 
 /**
  * Polyfill needed if you're using Node.js 18 or below
@@ -20,40 +21,57 @@ if (!globalThis.crypto) {
   });
 }
 
-/**
- * Database setup
- *
- * @link {@see https://lucia-auth.com/database/#database-setup}
- **/
-const adapter = BATI.has("drizzle")
-  ? new DrizzleSQLiteAdapter(drizzleDb(), sessionTable, userTable)
-  : new BetterSqlite3Adapter(sqliteDb(), {
-      user: "users",
-      session: "sessions",
-    });
+export function initializeLucia(
+  db: BATI.If<
+    {
+      'BATI.has("sqlite") && !BATI.hasD1': ReturnType<typeof sqliteDb>;
+      'BATI.has("drizzle") && !BATI.hasD1': ReturnType<typeof dbSqlite>;
+      'BATI.has("drizzle")': ReturnType<typeof dbD1>;
+      "BATI.hasD1": D1Database;
+    },
+    "union"
+  >,
+) {
+  /**
+   * Database setup
+   *
+   * @link {@see https://lucia-auth.com/database/#database-setup}
+   **/
+  const adapter = BATI.has("drizzle")
+    ? new DrizzleSQLiteAdapter(db as BATI.Any, sessionTable, userTable)
+    : BATI.hasD1
+      ? new D1Adapter(db as BATI.Any, {
+          user: "users",
+          session: "sessions",
+        })
+      : new BetterSqlite3Adapter(db as BATI.Any, {
+          user: "users",
+          session: "sessions",
+        });
 
-/**
- * Initialize Lucia
- *
- * @link {@see https://lucia-auth.com/getting-started/#initialize-lucia}
- */
-export const lucia = new Lucia(adapter, {
   /**
-   * Lucia Configuration
+   * Initialize Lucia
    *
-   * @link {@see https://lucia-auth.com/basics/configuration}
+   * @link {@see https://lucia-auth.com/getting-started/#initialize-lucia}
    */
-  sessionCookie: {
-    attributes: {
-      secure: process.env.NODE_ENV === "production",
+  return new Lucia(adapter, {
+    /**
+     * Lucia Configuration
+     *
+     * @link {@see https://lucia-auth.com/basics/configuration}
+     */
+    sessionCookie: {
+      attributes: {
+        secure: process.env.NODE_ENV === "production",
+      },
+    },
+    getUserAttributes: (attributes) => {
+      return {
+        username: attributes.username,
+      };
     },
-  },
-  getUserAttributes: (attributes) => {
-    return {
-      username: attributes.username,
-    };
-  },
-});
+  });
+}
 
 /**
  * Initialize OAuth provider
@@ -69,25 +87,43 @@ export const github = new GitHub(process.env.GITHUB_CLIENT_ID as string, process
  */
 declare module "lucia" {
   interface Register {
-    Lucia: typeof lucia;
+    Lucia: ReturnType<typeof initializeLucia>;
     DatabaseUserAttributes: Omit<DatabaseUser, "id">;
   }
 }
 
+declare global {
+  namespace Universal {
+    interface Context {
+      lucia: Register["Lucia"];
+      db: BATI.If<{
+        'BATI.has("sqlite") && !BATI.hasD1': ReturnType<typeof sqliteDb>;
+        'BATI.has("drizzle") && !BATI.hasD1': ReturnType<typeof dbSqlite>;
+        'BATI.has("drizzle")': ReturnType<typeof dbD1>;
+        "BATI.hasD1": D1Database;
+      }>;
+    }
+  }
+}
+
 export interface DatabaseUser {
   id: string;
   username: string;
-  password?: string;
+  password?: string | null;
 }
 
+//# !BATI.has("drizzle")
 export interface DatabaseOAuthAccount {
   provider_id: string;
   provider_user_id: string;
-  /*{ @if (it.BATI.has("drizzle")) }*/
-  userId: string;
-  /*{ #else }*/
   user_id: string;
-  /*{ /if }*/
+}
+
+//# BATI.has("drizzle")
+export interface DatabaseOAuthAccount {
+  providerId: string;
+  providerUserId: string;
+  userId: string;
 }
 
 export interface GitHubUser {

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

@@ -1,13 +1,32 @@
 import type { Session, User } from "lucia";
 import { generateId, Scrypt, verifyRequestOrigin } from "lucia";
-import type { DatabaseOAuthAccount, DatabaseUser, GitHubUser } from "../lib/lucia-auth";
-import { github, lucia } from "../lib/lucia-auth";
+import {
+  type DatabaseOAuthAccount,
+  type DatabaseUser,
+  github,
+  type GitHubUser,
+  initializeLucia,
+} from "../lib/lucia-auth";
 import { SqliteError } from "better-sqlite3";
 import { generateState, OAuth2RequestError } from "arctic";
 import { parse, serialize } from "cookie";
 import * as drizzleQueries from "@batijs/drizzle/database/drizzle/queries/lucia-auth";
 import * as sqliteQueries from "@batijs/sqlite/database/sqlite/queries/lucia-auth";
-import type { Get, UniversalHandler, UniversalMiddleware } from "@universal-middleware/core";
+import * as d1Queries from "@batijs/d1-sqlite/database/d1/queries/lucia-auth";
+import { type Get, type UniversalHandler, type UniversalMiddleware } from "@universal-middleware/core";
+
+/**
+ * Add lucia database to the context
+ *
+ * @link {@see https://universal-middleware.dev/examples/context-middleware}
+ */
+export const luciaDbMiddleware: Get<[], UniversalMiddleware> = () => async (_request, context, _runtime) => {
+  const lucia = initializeLucia(context.db);
+  return {
+    ...context,
+    lucia,
+  };
+};
 
 /**
  * CSRF protection middleware
@@ -35,8 +54,8 @@ export const luciaCsrfMiddleware = (() => async (request) => {
  *
  * @link {@see https://lucia-auth.com/guides/validate-session-cookies/}
  */
-export const luciaAuthContextMiddleware = (() => async (request, context) => {
-  const sessionId = lucia.readSessionCookie(request.headers.get("cookie") ?? "");
+export const luciaAuthContextMiddleware: Get<[], UniversalMiddleware> = () => async (request, context) => {
+  const sessionId = context.lucia.readSessionCookie(request.headers.get("cookie") ?? "");
 
   if (!sessionId) {
     return {
@@ -45,7 +64,7 @@ export const luciaAuthContextMiddleware = (() => async (request, context) => {
       user: null,
     };
   } else {
-    const { session, user } = await lucia.validateSession(sessionId);
+    const { session, user } = await context.lucia.validateSession(sessionId);
 
     return {
       ...context,
@@ -54,7 +73,7 @@ export const luciaAuthContextMiddleware = (() => async (request, context) => {
       user,
     };
   }
-}) satisfies Get<[], UniversalMiddleware>;
+};
 
 /**
  * Set Set-Cookie headers if in context
@@ -62,22 +81,25 @@ export const luciaAuthContextMiddleware = (() => async (request, context) => {
 export const luciaAuthCookieMiddleware = (() => (_request, context) => {
   return (response: Response) => {
     if (context.session?.fresh) {
-      response.headers.append("Set-Cookie", lucia.createSessionCookie(context.session.id).serialize());
+      response.headers.append("Set-Cookie", context.lucia.createSessionCookie(context.session.id).serialize());
     }
     if (context.sessionId && !context.session) {
-      response.headers.append("Set-Cookie", lucia.createBlankSessionCookie().serialize());
+      response.headers.append("Set-Cookie", context.lucia.createBlankSessionCookie().serialize());
     }
 
     return response;
   };
-}) satisfies Get<[], UniversalMiddleware<{ session?: Session | null; user?: User | null; sessionId?: string | null }>>;
+}) satisfies Get<
+  [],
+  UniversalMiddleware<Universal.Context & { 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 const luciaAuthSignupHandler = (() => async (request) => {
+export const luciaAuthSignupHandler = (() => async (request, context, _runtime) => {
   const body = (await request.json()) as { username: string; password: string };
   const username = body.username ?? "";
   const password = body.password ?? "";
@@ -106,15 +128,21 @@ export const luciaAuthSignupHandler = (() => async (request) => {
   const userId = generateId(15);
 
   try {
-    (BATI.has("drizzle") ? drizzleQueries : sqliteQueries).signupWithCredentials(userId, username, passwordHash);
+    if (BATI.has("drizzle")) {
+      await drizzleQueries.signupWithCredentials(context.db, userId, username, passwordHash);
+    } else if (BATI.has("sqlite") && !BATI.hasD1) {
+      sqliteQueries.signupWithCredentials(context.db, userId, username, passwordHash);
+    } else if (BATI.hasD1) {
+      await d1Queries.signupWithCredentials(context.db, userId, username, passwordHash);
+    }
 
-    const session = await lucia.createSession(userId, {});
+    const session = await context.lucia.createSession(userId, {});
 
     return new Response(JSON.stringify({ status: "success" }), {
       status: 200,
       headers: {
         "content-type": "application/json",
-        "set-cookie": lucia.createSessionCookie(session.id).serialize(),
+        "set-cookie": context.lucia.createSessionCookie(session.id).serialize(),
       },
     });
   } catch (error) {
@@ -141,7 +169,7 @@ export const luciaAuthSignupHandler = (() => async (request) => {
  *
  * @link {@see https://lucia-auth.com/guides/email-and-password/basics#sign-in-user}
  */
-export const luciaAuthLoginHandler = (() => async (request) => {
+export const luciaAuthLoginHandler = (() => async (request, context, _runtime) => {
   const body = (await request.json()) as { username: string; password: string };
   const username = body.username ?? "";
   const password = body.password ?? "";
@@ -157,9 +185,14 @@ export const luciaAuthLoginHandler = (() => async (request) => {
     });
   }
 
-  const existingUser = (BATI.has("drizzle") ? drizzleQueries : sqliteQueries).getExistingUser(username) as
-    | DatabaseUser
-    | undefined;
+  const existingUser: DatabaseUser | undefined | null = BATI.has("drizzle")
+    ? await drizzleQueries.getExistingUser(context.db, username)
+    : BATI.has("sqlite") && !BATI.hasD1
+      ? sqliteQueries.getExistingUser<DatabaseUser>(context.db, username)
+      : BATI.hasD1
+        ? await d1Queries.getExistingUser<DatabaseUser>(context.db, username)
+        : undefined;
+
   if (!existingUser) {
     return new Response(JSON.stringify({ error: { invalid: "Incorrect username or password" } }), {
       status: 422,
@@ -181,13 +214,13 @@ export const luciaAuthLoginHandler = (() => async (request) => {
     });
   }
 
-  const session = await lucia.createSession(existingUser.id, {});
+  const session = await context.lucia.createSession(existingUser.id, {});
 
   return new Response(JSON.stringify({ status: "success" }), {
     status: 200,
     headers: {
       "content-type": "application/json",
-      "set-cookie": lucia.createSessionCookie(session.id).serialize(),
+      "set-cookie": context.lucia.createSessionCookie(session.id).serialize(),
     },
   });
 }) satisfies Get<[], UniversalMiddleware>;
@@ -208,7 +241,7 @@ export const luciaAuthLogoutHandler = (() => async (_request, context) => {
    *
    * @link {@see https://lucia-auth.com/basics/sessions#invalidate-sessions}
    */
-  await lucia.invalidateSession(session.id);
+  await context.lucia.invalidateSession(session.id);
 
   /**
    * Delete session cookie
@@ -218,10 +251,10 @@ export const luciaAuthLogoutHandler = (() => async (_request, context) => {
   return new Response(JSON.stringify({ status: "success" }), {
     status: 200,
     headers: {
-      "set-cookie": lucia.createBlankSessionCookie().serialize(),
+      "set-cookie": context.lucia.createBlankSessionCookie().serialize(),
     },
   });
-}) satisfies Get<[], UniversalMiddleware<{ session?: Session | null }>>;
+}) satisfies Get<[], UniversalMiddleware<Universal.Context & { session?: Session | null }>>;
 
 /**
  * Github OAuth authorization handler
@@ -252,7 +285,7 @@ export const luciaGithubLoginHandler = (() => async () => {
  *
  * @link {@see https://lucia-auth.com/guides/oauth/basics#validate-callback}
  */
-export const luciaGithubCallbackHandler = (() => async (request) => {
+export const luciaGithubCallbackHandler = (() => async (request, context, _runtime) => {
   const cookies = parse(request.headers.get("cookie") ?? "");
   const params = new URL(request.url).searchParams;
   const code = params.get("code");
@@ -274,13 +307,18 @@ export const luciaGithubCallbackHandler = (() => async (request) => {
     });
     const githubUser = (await githubUserResponse.json()) as GitHubUser;
 
-    const existingAccount = (BATI.has("drizzle") ? drizzleQueries : sqliteQueries).getExistingAccount(
-      "github",
-      githubUser.id,
-    ) as DatabaseOAuthAccount | undefined;
+    const existingAccount: DatabaseOAuthAccount | undefined | null = BATI.has("drizzle")
+      ? ((await drizzleQueries.getExistingAccount(context.db, "github", githubUser.id)) as
+          | DatabaseOAuthAccount
+          | undefined)
+      : BATI.has("sqlite") && !BATI.hasD1
+        ? sqliteQueries.getExistingAccount<DatabaseOAuthAccount>(context.db, "github", githubUser.id)
+        : BATI.hasD1
+          ? await d1Queries.getExistingAccount<DatabaseOAuthAccount>(context.db, "github", githubUser.id)
+          : undefined;
 
     if (existingAccount) {
-      const session = await lucia.createSession(
+      const session = await context.lucia.createSession(
         BATI.has("drizzle") ? existingAccount.userId : existingAccount.user_id,
         {},
       );
@@ -288,22 +326,28 @@ export const luciaGithubCallbackHandler = (() => async (request) => {
         status: 302,
         headers: {
           Location: "/",
-          "set-cookie": lucia.createSessionCookie(session.id).serialize(),
+          "set-cookie": context.lucia.createSessionCookie(session.id).serialize(),
         },
       });
     }
 
     const userId = generateId(15);
 
-    (BATI.has("drizzle") ? drizzleQueries : sqliteQueries).signupWithGithub(userId, githubUser.login, githubUser.id);
+    if (BATI.has("drizzle")) {
+      await drizzleQueries.signupWithGithub(context.db, userId, githubUser.login, githubUser.id);
+    } else if (BATI.has("sqlite") && !BATI.hasD1) {
+      sqliteQueries.signupWithGithub(context.db, userId, githubUser.login, githubUser.id);
+    } else if (BATI.hasD1) {
+      await d1Queries.signupWithGithub(context.db, userId, githubUser.login, githubUser.id);
+    }
 
-    const session = await lucia.createSession(userId, {});
+    const session = await context.lucia.createSession(userId, {});
 
     return new Response(null, {
       status: 302,
       headers: {
         Location: "/",
-        "set-cookie": lucia.createSessionCookie(session.id).serialize(),
+        "set-cookie": context.lucia.createSessionCookie(session.id).serialize(),
       },
     });
   } catch (error) {

package/dist/boilerplates/@batijs/lucia-auth/types/lib/lucia-auth.d.ts

@@ -1,12 +1,15 @@
 import "dotenv/config";
-import { Lucia } from "lucia";
+import { Lucia, type Register } from "lucia";
 import { GitHub } from "arctic";
-/**
- * Initialize Lucia
- *
- * @link {@see https://lucia-auth.com/getting-started/#initialize-lucia}
- */
-export declare const lucia: Lucia<Record<never, never>, {
+import { dbD1, dbSqlite } from "@batijs/drizzle/database/drizzle/db";
+import { db as sqliteDb } from "@batijs/sqlite/database/sqlite/db";
+import { D1Database } from "@cloudflare/workers-types";
+export declare function initializeLucia(db: BATI.If<{
+    'BATI.has("sqlite") && !BATI.hasD1': ReturnType<typeof sqliteDb>;
+    'BATI.has("drizzle") && !BATI.hasD1': ReturnType<typeof dbSqlite>;
+    'BATI.has("drizzle")': ReturnType<typeof dbD1>;
+    "BATI.hasD1": D1Database;
+}, "union">): Lucia<Record<never, never>, {
     username: string;
 }>;
 /**
@@ -22,21 +25,38 @@ export declare const github: GitHub;
  */
 declare module "lucia" {
     interface Register {
-        Lucia: typeof lucia;
+        Lucia: ReturnType<typeof initializeLucia>;
         DatabaseUserAttributes: Omit<DatabaseUser, "id">;
     }
 }
+declare global {
+    namespace Universal {
+        interface Context {
+            lucia: Register["Lucia"];
+            db: BATI.If<{
+                'BATI.has("sqlite") && !BATI.hasD1': ReturnType<typeof sqliteDb>;
+                'BATI.has("drizzle") && !BATI.hasD1': ReturnType<typeof dbSqlite>;
+                'BATI.has("drizzle")': ReturnType<typeof dbD1>;
+                "BATI.hasD1": D1Database;
+            }>;
+        }
+    }
+}
 export interface DatabaseUser {
     id: string;
     username: string;
-    password?: string;
+    password?: string | null;
 }
 export interface DatabaseOAuthAccount {
     provider_id: string;
     provider_user_id: string;
-    userId: string;
     user_id: string;
 }
+export interface DatabaseOAuthAccount {
+    providerId: string;
+    providerUserId: string;
+    userId: string;
+}
 export interface GitHubUser {
     id: number;
     login: string;

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

@@ -1,4 +1,11 @@
 import type { Session, User } from "lucia";
+import { type Get, type UniversalMiddleware } from "@universal-middleware/core";
+/**
+ * Add lucia database to the context
+ *
+ * @link {@see https://universal-middleware.dev/examples/context-middleware}
+ */
+export declare const luciaDbMiddleware: Get<[], UniversalMiddleware>;
 /**
  * CSRF protection middleware
  *
@@ -10,18 +17,11 @@ export declare const luciaCsrfMiddleware: () => (request: Request) => Promise<Re
  *
  * @link {@see https://lucia-auth.com/guides/validate-session-cookies/}
  */
-export declare const luciaAuthContextMiddleware: () => (request: Request, context: Universal.Context) => Promise<{
-    session: null;
-    user: null;
-} | {
-    sessionId: string;
-    session: Session | null;
-    user: User | null;
-}>;
+export declare const luciaAuthContextMiddleware: Get<[], UniversalMiddleware>;
 /**
  * Set Set-Cookie headers if in context
  */
-export declare const luciaAuthCookieMiddleware: () => (_request: Request, context: {
+export declare const luciaAuthCookieMiddleware: () => (_request: Request, context: Universal.Context & {
     session?: Session | null;
     user?: User | null;
     sessionId?: string | null;
@@ -31,17 +31,17 @@ export declare const luciaAuthCookieMiddleware: () => (_request: Request, contex
  *
  * @link {@see https://lucia-auth.com/guides/email-and-password/basics#register-user}
  */
-export declare const luciaAuthSignupHandler: () => (request: Request) => Promise<Response>;
+export declare const luciaAuthSignupHandler: () => (request: Request, context: Universal.Context, _runtime: import("@universal-middleware/core").RuntimeAdapter) => Promise<Response>;
 /**
  * Sign in user handler
  *
  * @link {@see https://lucia-auth.com/guides/email-and-password/basics#sign-in-user}
  */
-export declare const luciaAuthLoginHandler: () => (request: Request) => Promise<Response>;
+export declare const luciaAuthLoginHandler: () => (request: Request, context: Universal.Context, _runtime: import("@universal-middleware/core").RuntimeAdapter) => Promise<Response>;
 /**
  * Log out user handler
  */
-export declare const luciaAuthLogoutHandler: () => (_request: Request, context: {
+export declare const luciaAuthLogoutHandler: () => (_request: Request, context: Universal.Context & {
     session?: Session | null;
 }) => Promise<Response>;
 /**
@@ -55,7 +55,7 @@ export declare const luciaGithubLoginHandler: () => () => Promise<Response>;
  *
  * @link {@see https://lucia-auth.com/guides/oauth/basics#validate-callback}
  */
-export declare const luciaGithubCallbackHandler: () => (request: Request) => Promise<Response>;
+export declare const luciaGithubCallbackHandler: () => (request: Request, context: Universal.Context, _runtime: import("@universal-middleware/core").RuntimeAdapter) => Promise<Response>;
 export declare function validateInput(username: string | null, password: string | null): {
     error: {
         username: string | null;

package/dist/boilerplates/@batijs/react-lucia-auth/files/pages/login/+Page.tsx

@@ -27,7 +27,8 @@ export default function Page() {
         body: JSON.stringify(formData),
         headers: { "Content-Type": "application/json" },
       });
-      const result = await response.json();
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const result: Record<string, any> = await response.json();
       if ("error" in result) {
         console.error("A validation error has occurred :", result.error);
         setError(result.error);

package/dist/boilerplates/@batijs/shared/files/vite.config.ts

@@ -16,6 +16,12 @@ export default defineConfig({
     //# BATI.has("hattip") && !BATI.has("vercel")
     hattip(),
   ],
+  //# BATI.hasD1
+  build: {
+    rollupOptions: {
+      external: ["wrangler"],
+    },
+  },
   //# BATI.has("vercel") && BATI.hasServer
   vercel: {
     additionalEndpoints: [

package/dist/boilerplates/@batijs/shared-db/files/server/db-middleware.ts

@@ -0,0 +1,37 @@
+/*# BATI include-if-imported #*/
+import type { Get, UniversalMiddleware } from "@universal-middleware/core";
+import { dbD1, dbSqlite } from "@batijs/drizzle/database/drizzle/db";
+import { db as sqliteDb } from "@batijs/sqlite/database/sqlite/db";
+import { getDbFromRuntime } from "@batijs/d1/database/d1/helpers";
+import { D1Database } from "@cloudflare/workers-types";
+
+//# BATI.hasDatabase
+declare global {
+  namespace Universal {
+    interface Context {
+      db: BATI.If<{
+        'BATI.has("sqlite") && !BATI.hasD1': ReturnType<typeof sqliteDb>;
+        'BATI.has("drizzle") && !BATI.hasD1': ReturnType<typeof dbSqlite>;
+        'BATI.has("drizzle")': ReturnType<typeof dbD1>;
+        "BATI.hasD1": D1Database;
+      }>;
+    }
+  }
+}
+
+// Add `db` to the Context
+export const dbMiddleware: Get<[], UniversalMiddleware> = () => async (_request, context, _runtime) => {
+  const db =
+    BATI.has("sqlite") && !BATI.hasD1
+      ? sqliteDb()
+      : BATI.has("drizzle") && !BATI.hasD1
+        ? dbSqlite()
+        : BATI.has("drizzle")
+          ? dbD1(await getDbFromRuntime(_runtime))
+          : await getDbFromRuntime(_runtime);
+
+  return {
+    ...context,
+    db: db as BATI.Any,
+  };
+};