@batijs/cli 0.0.259 → 0.0.260

package/dist/boilerplates/@batijs/sqlite/files/database/sqlite/queries/lucia-auth.ts

@@ -1,25 +1,26 @@
-import { db } from "../db";
-import type { Transaction } from "better-sqlite3";
+import type { Database, Transaction } from "better-sqlite3";
 
-export function getExistingUser(username: string) {
-  return db().prepare("SELECT * FROM users WHERE username = ?").get(username);
+export function getExistingUser<T>(db: Database, username: string) {
+  return db.prepare<[string], T>("SELECT * FROM users WHERE username = ?").get(username);
 }
 
-export function getExistingAccount(providerId: string, providerUserId: number) {
-  return db()
-    .prepare("SELECT * FROM oauth_accounts WHERE provider_id = ? AND provider_user_id = ?")
+export function getExistingAccount<T>(db: Database, providerId: string, providerUserId: number) {
+  return db
+    .prepare<[string, number], T>("SELECT * FROM oauth_accounts WHERE provider_id = ? AND provider_user_id = ?")
     .get(providerId, providerUserId);
 }
 
-export function signupWithGithub(userId: string, username: string, githubUserId: number): Transaction {
-  return db().transaction(() => {
-    db().prepare("INSERT INTO users (id, username) VALUES (?, ?)").run(userId, username);
-    db()
-      .prepare("INSERT INTO oauth_accounts (provider_id, provider_user_id, user_id) VALUES (?, ?, ?)")
-      .run("github", githubUserId, userId);
+export function signupWithGithub(db: Database, userId: string, username: string, githubUserId: number): Transaction {
+  return db.transaction(() => {
+    db.prepare("INSERT INTO users (id, username) VALUES (?, ?)").run(userId, username);
+    db.prepare("INSERT INTO oauth_accounts (provider_id, provider_user_id, user_id) VALUES (?, ?, ?)").run(
+      "github",
+      githubUserId,
+      userId,
+    );
   });
 }
 
-export function signupWithCredentials(userId: string, username: string, passwordHash: string) {
-  return db().prepare("INSERT INTO users (id, username, password) VALUES(?, ?, ?)").run(userId, username, passwordHash);
+export function signupWithCredentials(db: Database, userId: string, username: string, passwordHash: string) {
+  return db.prepare("INSERT INTO users (id, username, password) VALUES(?, ?, ?)").run(userId, username, passwordHash);
 }

package/dist/boilerplates/@batijs/sqlite/files/database/sqlite/queries/todos.ts

@@ -1,9 +1,9 @@
-import { db } from "../db";
+import type { Database } from "better-sqlite3";
 
-export function insertTodo(text: string) {
-  return db().prepare("INSERT INTO todos (text) VALUES (?)").run(text);
+export function insertTodo(db: Database, text: string) {
+  return db.prepare("INSERT INTO todos (text) VALUES (?)").run(text);
 }
 
-export function getAllTodos() {
-  return db().prepare<[], { id: number; text: string }>("SELECT * FROM todos").all();
+export function getAllTodos(db: Database) {
+  return db.prepare<[], { id: number; text: string }>("SELECT * FROM todos").all();
 }

package/dist/boilerplates/@batijs/sqlite/types/database/sqlite/queries/lucia-auth.d.ts

@@ -1,5 +1,5 @@
-import type { Transaction } from "better-sqlite3";
-export declare function getExistingUser(username: string): unknown;
-export declare function getExistingAccount(providerId: string, providerUserId: number): unknown;
-export declare function signupWithGithub(userId: string, username: string, githubUserId: number): Transaction;
-export declare function signupWithCredentials(userId: string, username: string, passwordHash: string): import("better-sqlite3").RunResult;
+import type { Database, Transaction } from "better-sqlite3";
+export declare function getExistingUser<T>(db: Database, username: string): T | undefined;
+export declare function getExistingAccount<T>(db: Database, providerId: string, providerUserId: number): T | undefined;
+export declare function signupWithGithub(db: Database, userId: string, username: string, githubUserId: number): Transaction;
+export declare function signupWithCredentials(db: Database, userId: string, username: string, passwordHash: string): import("better-sqlite3").RunResult;

package/dist/boilerplates/@batijs/sqlite/types/database/sqlite/queries/todos.d.ts

@@ -1,5 +1,6 @@
-export declare function insertTodo(text: string): import("better-sqlite3").RunResult;
-export declare function getAllTodos(): {
+import type { Database } from "better-sqlite3";
+export declare function insertTodo(db: Database, text: string): import("better-sqlite3").RunResult;
+export declare function getAllTodos(db: Database): {
     id: number;
     text: string;
 }[];

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

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

package/dist/boilerplates/@batijs/telefunc/files/pages/todo/TodoList.telefunc.ts

@@ -1,11 +1,18 @@
 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 { getContext } from "telefunc";
 
 export async function onNewTodo({ text }: { text: string }) {
   if (BATI.has("drizzle")) {
-    await drizzleQueries.insertTodo(text);
-  } else if (BATI.has("sqlite")) {
-    sqliteQueries.insertTodo(text);
+    const context = getContext();
+    await drizzleQueries.insertTodo(context.db, text);
+  } else if (BATI.has("sqlite") && !BATI.hasD1) {
+    const context = getContext();
+    sqliteQueries.insertTodo(context.db, text);
+  } else if (BATI.hasD1) {
+    const context = getContext();
+    await d1Queries.insertTodo(context.db, text);
   } else {
     // This is where you'd persist the data
     console.log("Received new todo", { text });

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

@@ -1,12 +1,25 @@
 import { telefunc } from "telefunc";
 import type { Get, UniversalHandler } from "@universal-middleware/core";
+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 telefuncHandler: Get<[], UniversalHandler> = () => async (request, context) => {
+export const telefuncHandler: Get<[], UniversalHandler> = () => async (request, context, runtime) => {
   const httpResponse = await telefunc({
     url: request.url.toString(),
     method: request.method,
     body: await request.text(),
-    context,
+    context: {
+      ...(context as 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 };
+      }>),
+      ...(runtime as BATI.If<{
+        "BATI.hasD1": { runtime: "workerd"; adapter: string; env: { DB: D1Database } };
+      }>),
+    },
   });
   const { body, statusCode, contentType } = httpResponse;
   return new Response(body, {

package/dist/boilerplates/@batijs/telefunc/files/vike.d.ts

@@ -0,0 +1,20 @@
+import { D1Database } from "@cloudflare/workers-types";
+import { dbD1, dbSqlite } from "@batijs/drizzle/database/drizzle/db";
+import { db as sqliteDb } from "@batijs/sqlite/database/sqlite/db";
+
+//# BATI.hasDatabase
+declare module "telefunc" {
+  namespace Telefunc {
+    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;
+        _: object;
+      }>;
+    }
+  }
+}
+
+export {};

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

@@ -43,12 +43,15 @@ var require_package = __commonJS({
       devDependencies: {
         "@batijs/compile": "workspace:*",
         "@batijs/drizzle": "workspace:*",
+        "@batijs/d1": "workspace:*",
+        "@batijs/d1-sqlite": "workspace:*",
         "@batijs/sqlite": "workspace:*",
-        "@batijs/shared-no-db": "workspace:*",
         "@batijs/shared-todo": "workspace:*",
+        "@cloudflare/workers-types": "^4.20240821.1",
         "@trpc/client": "^10.45.2",
         "@trpc/server": "^10.45.2",
         "@types/node": "^18.19.14",
+        "@universal-middleware/core": "^0.2.6",
         vite: "^5.4.2"
       },
       dependencies: {
@@ -67,11 +70,11 @@ var require_package = __commonJS({
           "trpc/server": [
             "./dist/types/trpc/server.d.ts"
           ],
+          "server/trpc-handler": [
+            "./dist/types/server/trpc-handler.d.ts"
+          ],
           "trpc/client": [
             "./dist/types/trpc/client.d.ts"
-          ],
-          "trpc/vite-plugin": [
-            "./dist/types/trpc/vite-plugin.d.ts"
           ]
         }
       },
@@ -79,11 +82,11 @@ var require_package = __commonJS({
         "./trpc/server": {
           types: "./dist/types/trpc/server.d.ts"
         },
+        "./server/trpc-handler": {
+          types: "./dist/types/server/trpc-handler.d.ts"
+        },
         "./trpc/client": {
           types: "./dist/types/trpc/client.d.ts"
-        },
-        "./trpc/vite-plugin": {
-          types: "./dist/types/trpc/vite-plugin.d.ts"
         }
       }
     };

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

@@ -0,0 +1,22 @@
+/*# BATI include-if-imported #*/
+import { appRouter } from "../trpc/server";
+import type { Get, UniversalHandler } from "@universal-middleware/core";
+import { fetchRequestHandler } from "@trpc/server/adapters/fetch";
+
+export const trpcHandler = ((endpoint) => (request, context, runtime) => {
+  return fetchRequestHandler({
+    endpoint,
+    req: request,
+    router: appRouter,
+    createContext({ req, resHeaders }) {
+      return {
+        ...(context as BATI.Any),
+        ...(runtime as BATI.If<{
+          "BATI.hasD1": { runtime: "workerd"; adapter: string; env: { DB: D1Database } };
+        }>),
+        req,
+        resHeaders,
+      };
+    },
+  });
+}) satisfies Get<[endpoint: string], UniversalHandler>;

package/dist/boilerplates/@batijs/trpc/files/trpc/server.ts

@@ -1,12 +1,26 @@
 import { initTRPC } from "@trpc/server";
 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 { D1Database } from "@cloudflare/workers-types";
 
 /**
  * Initialization of tRPC backend
  * Should be done only once per backend!
  */
-const t = initTRPC.create();
+const t = initTRPC
+  .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;
+    }>
+  >()
+  .create();
 
 /**
  * Export reusable router and procedure helpers
@@ -28,9 +42,11 @@ export const appRouter = router({
     })
     .mutation(async (opts) => {
       if (BATI.has("drizzle")) {
-        await drizzleQueries.insertTodo(opts.input);
-      } else if (BATI.has("sqlite")) {
-        sqliteQueries.insertTodo(opts.input);
+        await drizzleQueries.insertTodo(opts.ctx.db, opts.input);
+      } else if (BATI.has("sqlite") && !BATI.hasD1) {
+        sqliteQueries.insertTodo(opts.ctx.db, opts.input);
+      } else if (BATI.hasD1) {
+        await d1Queries.insertTodo(opts.ctx.db, opts.input);
       } else {
         // This is where you'd persist the data
         console.log("Received new todo", { text: opts.input });

package/dist/boilerplates/@batijs/trpc/types/server/trpc-handler.d.ts

@@ -0,0 +1 @@
+export declare const trpcHandler: (endpoint: string) => (request: Request<unknown, CfProperties<unknown>>, context: Universal.Context, runtime: import("@universal-middleware/core").RuntimeAdapter) => Promise<Response>;

package/dist/boilerplates/@batijs/trpc/types/trpc/client.d.ts

@@ -2,12 +2,28 @@ export declare const trpc: {
     demo: {
         query: import("@trpc/client").Resolver<import("@trpc/server").BuildProcedure<"query", {
             _config: import("@trpc/server").RootConfig<{
-                ctx: object;
+                ctx: object & {
+                    db: ReturnType<typeof import("@batijs/sqlite/database/sqlite/db").db>;
+                } & {
+                    db: ReturnType<typeof import("@batijs/drizzle/database/drizzle/db").dbSqlite>;
+                } & {
+                    db: ReturnType<typeof import("@batijs/drizzle/database/drizzle/db").dbD1>;
+                } & {
+                    db: import("@cloudflare/workers-types").D1Database;
+                };
                 meta: object;
                 errorShape: import("@trpc/server").DefaultErrorShape;
                 transformer: import("@trpc/server").DefaultDataTransformer;
             }>;
-            _ctx_out: object;
+            _ctx_out: object & {
+                db: ReturnType<typeof import("@batijs/sqlite/database/sqlite/db").db>;
+            } & {
+                db: ReturnType<typeof import("@batijs/drizzle/database/drizzle/db").dbSqlite>;
+            } & {
+                db: ReturnType<typeof import("@batijs/drizzle/database/drizzle/db").dbD1>;
+            } & {
+                db: import("@cloudflare/workers-types").D1Database;
+            };
             _input_in: typeof import("@trpc/server").unsetMarker;
             _input_out: typeof import("@trpc/server").unsetMarker;
             _output_in: typeof import("@trpc/server").unsetMarker;
@@ -20,13 +36,29 @@ export declare const trpc: {
     onNewTodo: {
         mutate: import("@trpc/client").Resolver<import("@trpc/server").BuildProcedure<"mutation", {
             _config: import("@trpc/server").RootConfig<{
-                ctx: object;
+                ctx: object & {
+                    db: ReturnType<typeof import("@batijs/sqlite/database/sqlite/db").db>;
+                } & {
+                    db: ReturnType<typeof import("@batijs/drizzle/database/drizzle/db").dbSqlite>;
+                } & {
+                    db: ReturnType<typeof import("@batijs/drizzle/database/drizzle/db").dbD1>;
+                } & {
+                    db: import("@cloudflare/workers-types").D1Database;
+                };
                 meta: object;
                 errorShape: import("@trpc/server").DefaultErrorShape;
                 transformer: import("@trpc/server").DefaultDataTransformer;
             }>;
             _meta: object;
-            _ctx_out: object;
+            _ctx_out: object & {
+                db: ReturnType<typeof import("@batijs/sqlite/database/sqlite/db").db>;
+            } & {
+                db: ReturnType<typeof import("@batijs/drizzle/database/drizzle/db").dbSqlite>;
+            } & {
+                db: ReturnType<typeof import("@batijs/drizzle/database/drizzle/db").dbD1>;
+            } & {
+                db: import("@cloudflare/workers-types").D1Database;
+            };
             _input_in: string;
             _input_out: string;
             _output_in: typeof import("@trpc/server").unsetMarker;

package/dist/boilerplates/@batijs/trpc/types/trpc/server.d.ts

@@ -1,21 +1,48 @@
+import type { dbD1, dbSqlite } from "@batijs/drizzle/database/drizzle/db";
+import type { db as sqliteDb } from "@batijs/sqlite/database/sqlite/db";
+import { D1Database } from "@cloudflare/workers-types";
 /**
  * Export reusable router and procedure helpers
  * that can be used throughout the router
  */
 export declare const router: <TProcRouterRecord extends import("@trpc/server").ProcedureRouterRecord>(procedures: TProcRouterRecord) => import("@trpc/server").CreateRouterInner<import("@trpc/server").RootConfig<{
-    ctx: object;
+    ctx: object & {
+        db: ReturnType<typeof sqliteDb>;
+    } & {
+        db: ReturnType<typeof dbSqlite>;
+    } & {
+        db: ReturnType<typeof dbD1>;
+    } & {
+        db: D1Database;
+    };
     meta: object;
     errorShape: import("@trpc/server").DefaultErrorShape;
     transformer: import("@trpc/server").DefaultDataTransformer;
 }>, TProcRouterRecord>;
 export declare const publicProcedure: import("@trpc/server").ProcedureBuilder<{
     _config: import("@trpc/server").RootConfig<{
-        ctx: object;
+        ctx: object & {
+            db: ReturnType<typeof sqliteDb>;
+        } & {
+            db: ReturnType<typeof dbSqlite>;
+        } & {
+            db: ReturnType<typeof dbD1>;
+        } & {
+            db: D1Database;
+        };
         meta: object;
         errorShape: import("@trpc/server").DefaultErrorShape;
         transformer: import("@trpc/server").DefaultDataTransformer;
     }>;
-    _ctx_out: object;
+    _ctx_out: object & {
+        db: ReturnType<typeof sqliteDb>;
+    } & {
+        db: ReturnType<typeof dbSqlite>;
+    } & {
+        db: ReturnType<typeof dbD1>;
+    } & {
+        db: D1Database;
+    };
     _input_in: typeof import("@trpc/server").unsetMarker;
     _input_out: typeof import("@trpc/server").unsetMarker;
     _output_in: typeof import("@trpc/server").unsetMarker;
@@ -23,19 +50,43 @@ export declare const publicProcedure: import("@trpc/server").ProcedureBuilder<{
     _meta: object;
 }>;
 export declare const appRouter: import("@trpc/server").CreateRouterInner<import("@trpc/server").RootConfig<{
-    ctx: object;
+    ctx: object & {
+        db: ReturnType<typeof sqliteDb>;
+    } & {
+        db: ReturnType<typeof dbSqlite>;
+    } & {
+        db: ReturnType<typeof dbD1>;
+    } & {
+        db: D1Database;
+    };
     meta: object;
     errorShape: import("@trpc/server").DefaultErrorShape;
     transformer: import("@trpc/server").DefaultDataTransformer;
 }>, {
     demo: import("@trpc/server").BuildProcedure<"query", {
         _config: import("@trpc/server").RootConfig<{
-            ctx: object;
+            ctx: object & {
+                db: ReturnType<typeof sqliteDb>;
+            } & {
+                db: ReturnType<typeof dbSqlite>;
+            } & {
+                db: ReturnType<typeof dbD1>;
+            } & {
+                db: D1Database;
+            };
             meta: object;
             errorShape: import("@trpc/server").DefaultErrorShape;
             transformer: import("@trpc/server").DefaultDataTransformer;
         }>;
-        _ctx_out: object;
+        _ctx_out: object & {
+            db: ReturnType<typeof sqliteDb>;
+        } & {
+            db: ReturnType<typeof dbSqlite>;
+        } & {
+            db: ReturnType<typeof dbD1>;
+        } & {
+            db: D1Database;
+        };
         _input_in: typeof import("@trpc/server").unsetMarker;
         _input_out: typeof import("@trpc/server").unsetMarker;
         _output_in: typeof import("@trpc/server").unsetMarker;
@@ -46,13 +97,29 @@ export declare const appRouter: import("@trpc/server").CreateRouterInner<import(
     }>;
     onNewTodo: import("@trpc/server").BuildProcedure<"mutation", {
         _config: import("@trpc/server").RootConfig<{
-            ctx: object;
+            ctx: object & {
+                db: ReturnType<typeof sqliteDb>;
+            } & {
+                db: ReturnType<typeof dbSqlite>;
+            } & {
+                db: ReturnType<typeof dbD1>;
+            } & {
+                db: D1Database;
+            };
             meta: object;
             errorShape: import("@trpc/server").DefaultErrorShape;
             transformer: import("@trpc/server").DefaultDataTransformer;
         }>;
         _meta: object;
-        _ctx_out: object;
+        _ctx_out: object & {
+            db: ReturnType<typeof sqliteDb>;
+        } & {
+            db: ReturnType<typeof dbSqlite>;
+        } & {
+            db: ReturnType<typeof dbD1>;
+        } & {
+            db: D1Database;
+        };
         _input_in: string;
         _input_out: string;
         _output_in: typeof import("@trpc/server").unsetMarker;

package/dist/boilerplates/@batijs/ts-rest/files/$package.json.js

@@ -43,12 +43,14 @@ var require_package = __commonJS({
       devDependencies: {
         "@batijs/compile": "workspace:*",
         "@batijs/drizzle": "workspace:*",
+        "@batijs/d1": "workspace:*",
+        "@batijs/d1-sqlite": "workspace:*",
         "@batijs/sqlite": "workspace:*",
-        "@batijs/shared-no-db": "workspace:*",
+        "@cloudflare/workers-types": "^4.20240821.1",
         "@ts-rest/core": "^3.51.0",
         "@ts-rest/serverless": "^3.51.0",
         "@types/node": "^18.19.14",
-        "@universal-middleware/core": "^0.2.5",
+        "@universal-middleware/core": "^0.2.6",
         zod: "^3.23.8"
       },
       dependencies: {
@@ -98,7 +100,6 @@ async function getPackageJson(props) {
     dependencies: ["@ts-rest/core", "@ts-rest/serverless", "@universal-middleware/core"],
     devDependencies: ["zod"]
   });
-  packageJson.devDependencies.typescript = "~5.4.5";
   return packageJson;
 }
 export {

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

@@ -2,44 +2,65 @@ import { fetchRequestHandler, tsr } from "@ts-rest/serverless/fetch";
 import { contract } from "../ts-rest/contract";
 import { Get, UniversalHandler } from "@universal-middleware/core";
 import * as drizzleQueries from "@batijs/drizzle/database/drizzle/queries/todos";
+import { dbD1, dbSqlite } from "@batijs/drizzle/database/drizzle/db";
 import * as sqliteQueries from "@batijs/sqlite/database/sqlite/queries/todos";
+import { db as sqliteDb } from "@batijs/sqlite/database/sqlite/db";
+import * as d1Queries from "@batijs/d1-sqlite/database/d1/queries/todos";
+import type { D1Database } from "@cloudflare/workers-types";
 
 /**
  * ts-rest route
  *
  * @link {@see https://ts-rest.com/docs/serverless/fetch-runtimes/}
  **/
-const router = tsr.router(contract, {
-  demo: async () => {
-    return {
-      status: 200,
-      body: {
-        demo: true,
-      },
-    };
-  },
-  createTodo: async ({ body }) => {
-    if (BATI.has("drizzle")) {
-      await drizzleQueries.insertTodo(body.text);
-    } else if (BATI.has("sqlite")) {
-      sqliteQueries.insertTodo(body.text);
-    } else {
-      // This is where you'd persist the data
-      console.log("Received new todo", { text: body.text });
-    }
-    return {
-      status: 200,
-      body: {
-        status: "Ok",
-      },
-    };
-  },
-});
+const router = tsr
+  .platformContext<
+    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;
+    }>
+  >()
+  .router(contract, {
+    demo: async () => {
+      return {
+        status: 200,
+        body: {
+          demo: true,
+        },
+      };
+    },
+    createTodo: async ({ body }, _ctx) => {
+      if (BATI.has("drizzle")) {
+        await drizzleQueries.insertTodo(_ctx.db, body.text);
+      } else if (BATI.has("sqlite") && !BATI.hasD1) {
+        sqliteQueries.insertTodo(_ctx.db, body.text);
+      } else if (BATI.hasD1) {
+        await d1Queries.insertTodo(_ctx.db, body.text);
+      } else {
+        // This is where you'd persist the data
+        console.log("Received new todo", { text: body.text });
+      }
+      return {
+        status: 200,
+        body: {
+          status: "Ok",
+        },
+      };
+    },
+  });
 
-export const tsRestHandler: Get<[], UniversalHandler> = () => async (request) =>
+export const tsRestHandler: Get<[], UniversalHandler> = () => async (request, ctx, runtime) =>
   fetchRequestHandler({
     request: new Request(request.url, request),
     contract,
     router,
     options: {},
+    platformContext: {
+      ...ctx,
+      ...runtime,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any,
   });

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

@@ -73,7 +73,8 @@ async function handleOnSubmit(action: "login" | "signup") {
       body: JSON.stringify(formData.value),
       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);
       error.value = { ...result.error };