@batijs/cli 0.0.259 → 0.0.260

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,
+  };
+};

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

@@ -0,0 +1,17 @@
+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 { D1Database } from "@cloudflare/workers-types";
+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;
+            }>;
+        }
+    }
+}
+export declare const dbMiddleware: Get<[], UniversalMiddleware>;

package/dist/boilerplates/@batijs/shared-no-db/files/$package.json.js

@@ -55,7 +55,8 @@ var require_package = __commonJS({
           flag: {
             $not: {
               $in: [
-                "drizzle"
+                "drizzle",
+                "sqlite"
               ]
             }
           }

package/dist/boilerplates/@batijs/shared-server/files/$package.json.js

@@ -45,11 +45,14 @@ var require_package = __commonJS({
         "@batijs/compile": "workspace:*",
         "@batijs/core": "workspace:*",
         "@batijs/drizzle": "workspace:*",
-        "@batijs/sqlite": "workspace:*",
+        "@batijs/d1": "workspace:*",
+        "@batijs/d1-sqlite": "workspace:*",
         "@batijs/features": "workspace:*",
         "@batijs/shared-no-db": "workspace:*",
+        "@batijs/sqlite": "workspace:*",
         "@types/node": "^18.19.14",
-        "@universal-middleware/core": "^0.2.5",
+        "@universal-middleware/core": "^0.2.6",
+        "@cloudflare/workers-types": "^4.20240821.1",
         vike: "^0.4.193",
         vite: "^5.4.2"
       },

package/dist/boilerplates/@batijs/shared-server/files/server/create-todo-handler.ts

@@ -2,15 +2,33 @@
 import type { Get, UniversalHandler } from "@universal-middleware/core";
 import * as drizzleQueries from "@batijs/drizzle/database/drizzle/queries/todos";
 import * as sqliteQueries from "@batijs/sqlite/database/sqlite/queries/todos";
+import * as d1Queries from "@batijs/d1-sqlite/database/d1/queries/todos";
+import type { dbD1, dbSqlite } from "@batijs/drizzle/database/drizzle/db";
+import type { db as sqliteDb } from "@batijs/sqlite/database/sqlite/db";
+import type { D1Database } from "@cloudflare/workers-types";
 
-export const createTodoHandler: Get<[], UniversalHandler> = () => async (request) => {
+export const createTodoHandler: Get<
+  [],
+  UniversalHandler<
+    Universal.Context &
+      BATI.If<{
+        'BATI.has("sqlite") && !BATI.hasD1': { db: ReturnType<typeof sqliteDb> };
+        'BATI.has("drizzle") && !BATI.hasD1': { db: ReturnType<typeof dbSqlite> };
+        'BATI.has("drizzle")': { db: ReturnType<typeof dbD1> };
+        "BATI.hasD1": { db: D1Database };
+        _: object;
+      }>
+  >
+> = () => async (request, _context, _runtime) => {
   // In a real case, user-provided data should ALWAYS be validated with tools like zod
   const newTodo = (await request.json()) as { text: string };
 
   if (BATI.has("drizzle")) {
-    await drizzleQueries.insertTodo(newTodo.text);
-  } else if (BATI.has("sqlite")) {
-    sqliteQueries.insertTodo(newTodo.text);
+    await drizzleQueries.insertTodo(_context.db, newTodo.text);
+  } else if (BATI.has("sqlite") && !BATI.hasD1) {
+    sqliteQueries.insertTodo(_context.db, newTodo.text);
+  } else if (BATI.hasD1) {
+    await d1Queries.insertTodo(_context.db, newTodo.text);
   } else {
     // This is where you'd persist the data
     console.log("Received new todo", newTodo);

package/dist/boilerplates/@batijs/shared-server/files/server/vike-handler.ts

@@ -3,8 +3,8 @@
 import { renderPage } from "vike/server";
 import type { Get, UniversalHandler } from "@universal-middleware/core";
 
-export const vikeHandler: Get<[], UniversalHandler> = () => async (request, context) => {
-  const pageContextInit = { ...context, urlOriginal: request.url, headersOriginal: request.headers };
+export const vikeHandler: Get<[], UniversalHandler> = () => async (request, context, runtime) => {
+  const pageContextInit = { ...context, ...runtime, urlOriginal: request.url, headersOriginal: request.headers };
   const pageContext = await renderPage(pageContextInit);
   const response = pageContext.httpResponse;
 

package/dist/boilerplates/@batijs/shared-server/types/server/create-todo-handler.d.ts

@@ -1,2 +1,20 @@
 import type { Get, UniversalHandler } from "@universal-middleware/core";
-export declare const createTodoHandler: Get<[], UniversalHandler>;
+import type { dbD1, dbSqlite } from "@batijs/drizzle/database/drizzle/db";
+import type { db as sqliteDb } from "@batijs/sqlite/database/sqlite/db";
+import type { D1Database } from "@cloudflare/workers-types";
+export declare const createTodoHandler: Get<[
+], UniversalHandler<Universal.Context & BATI.If<{
+    'BATI.has("sqlite") && !BATI.hasD1': {
+        db: ReturnType<typeof sqliteDb>;
+    };
+    'BATI.has("drizzle") && !BATI.hasD1': {
+        db: ReturnType<typeof dbSqlite>;
+    };
+    'BATI.has("drizzle")': {
+        db: ReturnType<typeof dbD1>;
+    };
+    "BATI.hasD1": {
+        db: D1Database;
+    };
+    _: object;
+}>>>;

package/dist/boilerplates/@batijs/shared-todo/files/pages/todo/+data.ts

@@ -2,18 +2,24 @@
 import { todos } from "@batijs/shared-no-db/database/todoItems";
 import * as drizzleQueries from "@batijs/drizzle/database/drizzle/queries/todos";
 import * as sqliteQueries from "@batijs/sqlite/database/sqlite/queries/todos";
+import * as d1Queries from "@batijs/d1-sqlite/database/d1/queries/todos";
+import type { PageContextServer } from "vike/types";
 
 export type Data = {
   todo: { text: string }[];
 };
 
-export default async function data(): Promise<Data> {
+export default async function data(_pageContext: PageContextServer): Promise<Data> {
   if (BATI.has("drizzle")) {
-    const todo = drizzleQueries.getAllTodos();
+    const todo = await drizzleQueries.getAllTodos(_pageContext.db);
 
     return { todo };
-  } else if (BATI.has("sqlite")) {
-    const todo = sqliteQueries.getAllTodos();
+  } else if (BATI.has("sqlite") && !BATI.hasD1) {
+    const todo = sqliteQueries.getAllTodos(_pageContext.db);
+
+    return { todo };
+  } else if (BATI.hasD1) {
+    const todo = await d1Queries.getAllTodos(_pageContext.db);
 
     return { todo };
   } else {

package/dist/boilerplates/@batijs/shared-todo/files/vike.d.ts

@@ -0,0 +1,19 @@
+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";
+
+//# BATI.hasDatabase
+declare global {
+  namespace Vike {
+    interface PageContext {
+      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 {};

package/dist/boilerplates/@batijs/shared-todo/types/pages/todo/+data.d.ts

@@ -1,6 +1,7 @@
+import type { PageContextServer } from "vike/types";
 export type Data = {
     todo: {
         text: string;
     }[];
 };
-export default function data(): Promise<Data>;
+export default function data(_pageContext: PageContextServer): Promise<Data>;

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

@@ -28,7 +28,8 @@ export function Page() {
         body: JSON.stringify(untrack(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/sqlite/files/$.env.js

@@ -1,6 +1,7 @@
 // files/$.env.ts
 import { appendToEnv } from "@batijs/core";
 async function getEnv(props) {
+  if (props.meta.BATI.hasD1) return;
   const envContent = await props.readfile?.();
   return appendToEnv(envContent, "DATABASE_URL", "sqlite.db", "Path to the sqlite database");
 }

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

@@ -56,7 +56,16 @@ var require_package = __commonJS({
       ],
       bati: {
         if: {
-          flag: "sqlite"
+          flag: {
+            $in: [
+              "sqlite"
+            ],
+            $not: {
+              $in: [
+                "cloudflare"
+              ]
+            }
+          }
         }
       },
       exports: {