@batijs/cli 0.0.259 → 0.0.261

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: {

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;