@batijs/cli 0.0.259 → 0.0.261

package/dist/boilerplates/@batijs/aws/files/tests/aws_handler.spec.ts

@@ -0,0 +1,116 @@
+import { beforeAll, describe, expect, it } from "vitest";
+
+import { execSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import path from "node:path";
+import * as which from "which";
+
+const bunExists = which.sync("bun", { nothrow: true }) !== null;
+const npmCli = bunExists ? "bun" : "pnpm";
+
+console.log("RUN TESTS ***");
+
+describe("AWSHandler", () => {
+  beforeAll(
+    async () => {
+      if (existsSync(path.join(process.cwd(), "cdk.out"))) {
+        rmSync(path.join(process.cwd(), "cdk.out"), { recursive: true });
+      }
+      /*
+       * `--build "${npmCli} run build"` is required to build the project before synth
+       */
+      const synthCommand = `${npmCli} run cdk --json --build "${npmCli} run build" synth`;
+      execSync(synthCommand, {
+        encoding: "utf8",
+        maxBuffer: 50 * 1024 * 1024,
+        env: {
+          BUN_LOCKFILE: "../../bun.lockb", // This is to make sure that the correct lockfile is used in a bun project
+          PATH: process.env.PATH,
+        },
+      });
+    },
+    2 * 60 * 1000,
+  );
+
+  it("should request a page from the AWS handler", async () => {
+    const cdkOutPath = path.join(process.cwd(), "cdk.out");
+    const templateFilePath = readdirSync(cdkOutPath).find(
+      (file) => file.startsWith("VikeStack-") && file.endsWith(".template.json"),
+    );
+    const templateFullPath = path.join(cdkOutPath, templateFilePath!);
+    expect(existsSync(templateFullPath)).toBe(true);
+    const cloudfrontTemplateJson = readFileSync(templateFullPath, "utf8");
+    const requestHandlerFolder = extractRequestHandlerPath(
+      JSON.parse(cloudfrontTemplateJson),
+      "/RequestHandler/Resource",
+    );
+    const requestHandlerPath = path.join(process.cwd(), "cdk.out", requestHandlerFolder!, "index.mjs");
+    expect(existsSync(requestHandlerPath)).toBe(true);
+
+    const { handler } = await import(requestHandlerPath);
+    const event = {
+      version: "2.0",
+      routeKey: "$default",
+      rawPath: "/",
+      rawQueryString: "",
+      headers: {
+        accept: "*/*",
+        "content-length": "0",
+        host: "example.com",
+        "user-agent": "PostmanRuntime/7.26.8",
+        "x-amzn-trace-id": "Root=1-5f84c7a9-0e5b1e1e1e1e1e1e1e1e1e1e",
+        "x-forwarded-for": "127.0.0.1",
+        "x-forwarded-port": "443",
+        "x-forwarded-proto": "https",
+      },
+      requestContext: {
+        accountId: "123456789012",
+        apiId: "api-id",
+        domainName: "example.com",
+        domainPrefix: "example",
+        http: {
+          method: "GET",
+          path: "/",
+          protocol: "HTTP/1.1",
+          sourceIp: "127.0.0.1",
+          userAgent: "PostmanRuntime/7.26.8",
+        },
+        requestId: "id",
+        routeKey: "$default",
+        stage: "$default",
+        time: "12/Mar/2021:19:03:58 +0000",
+        timeEpoch: 1615578238000,
+      },
+      isBase64Encoded: false,
+    };
+    const response = await handler(event, {});
+    expect(response.statusCode).toBe(200);
+    const body = response.isBase64Encoded ? Buffer.from(response.body, "base64").toString("utf8") : response.body;
+    expect(body).toContain("My Vike App");
+  });
+});
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type JsonData = Record<string, any>;
+
+function extractRequestHandlerPath(jsonData: JsonData, targetCdkPath: string): string | null {
+  let assetPath: string | null = null;
+
+  function traverse(obj: JsonData) {
+    if (typeof obj !== "object" || obj === null) return;
+
+    if (obj?.["aws:cdk:path"]?.endsWith(targetCdkPath)) {
+      assetPath = obj?.["aws:asset:path"];
+      return;
+    }
+
+    for (const key in obj) {
+      if (obj?.[key]) {
+        traverse(obj[key]);
+      }
+    }
+  }
+
+  traverse(jsonData);
+  return assetPath;
+}

package/dist/boilerplates/@batijs/aws/files/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["tests/**/*.spec.ts"], // Adjust the pattern as needed
+    watch: false,
+  },
+});

package/dist/boilerplates/@batijs/aws/types/cdk/bin/infrastructure.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import "source-map-support/register";
+import * as cdk from "aws-cdk-lib";
+import * as certificatemanager from "aws-cdk-lib/aws-certificatemanager";
+import * as route53 from "aws-cdk-lib/aws-route53";
+export type CustomStackProps = cdk.StackProps & {
+    domainName?: string;
+    subDomain?: string;
+    certificate?: string | certificatemanager.ICertificate;
+    hostedZone?: route53.IHostedZone;
+};

package/dist/boilerplates/@batijs/aws/types/cdk/lib/vike-stack.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import "source-map-support/register";
+import { Construct } from "constructs";
+import * as cdk from "aws-cdk-lib";
+import type { CustomStackProps } from "../bin/infrastructure";
+type VikeStackProps = cdk.StackProps & {
+    customStackProps: CustomStackProps;
+};
+export declare class VikeStack extends cdk.Stack {
+    readonly distributionUrlParameterName: string;
+    constructor(scope: Construct, id: string, props: VikeStackProps);
+}
+export {};

package/dist/boilerplates/@batijs/aws/types/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

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

@@ -46,7 +46,7 @@ var require_package = __commonJS({
         "@hattip/adapter-cloudflare-workers": "^0.0.47",
         "@types/node": "^18.19.14",
         "npm-run-all2": "^6.2.2",
-        "vike-cloudflare": "^0.1.0",
+        "vike-cloudflare": "^0.1.1",
         wrangler: "^3.72.2"
       },
       dependencies: {

package/dist/boilerplates/@batijs/cloudflare/files/$tsconfig.json.js

@@ -0,0 +1,10 @@
+// files/$tsconfig.json.ts
+import { loadAsJson } from "@batijs/core";
+async function getTsConfig(props) {
+  const tsConfig = await loadAsJson(props);
+  tsConfig.compilerOptions.types = [...tsConfig.compilerOptions.types ?? [], "vike-cloudflare/types"];
+  return tsConfig;
+}
+export {
+  getTsConfig as default
+};

package/dist/boilerplates/@batijs/d1/files/$README.md.js

@@ -5,10 +5,6 @@ async function getReadme(props) {
   const todo = `
 ## *Cloudflare D1*
 
-> [!IMPORTANT]
-> D1 integration is incomplete, and some files are still refering to \`better-sqlite3\`.
-> It should be fixed within a few days.
-
 ### Setup
 Create a D1 database:
 

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

@@ -0,0 +1,96 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module) {
+    module.exports = {
+      name: "@batijs/d1",
+      private: true,
+      version: "0.0.1",
+      description: "",
+      type: "module",
+      scripts: {
+        "check-types": "tsc --noEmit",
+        build: "bati-compile-boilerplate"
+      },
+      keywords: [],
+      author: "",
+      license: "MIT",
+      devDependencies: {
+        "@batijs/compile": "workspace:*",
+        "@universal-middleware/core": "^0.2.6",
+        "@cloudflare/workers-types": "^4.20240821.1",
+        "@types/node": "^18.19.14",
+        vike: "^0.4.193",
+        wrangler: "^3.72.2"
+      },
+      dependencies: {
+        "@batijs/core": "workspace:*"
+      },
+      files: [
+        "dist/"
+      ],
+      bati: {
+        if: {
+          flag: {
+            $in: [
+              "drizzle",
+              "sqlite"
+            ],
+            $all: [
+              "cloudflare"
+            ]
+          }
+        }
+      },
+      exports: {
+        "./database/d1/helpers": {
+          types: "./dist/types/database/d1/helpers.d.ts"
+        }
+      },
+      typesVersions: {
+        "*": {
+          "database/d1/helpers": [
+            "./dist/types/database/d1/helpers.d.ts"
+          ]
+        }
+      }
+    };
+  }
+});
+
+// files/$package.json.ts
+import { addDependency, loadAsJson } from "@batijs/core";
+async function getPackageJson(props) {
+  const packageJson = await loadAsJson(props);
+  return addDependency(packageJson, await Promise.resolve().then(() => __toESM(require_package(), 1)).then((x) => x.default), {
+    devDependencies: ["@universal-middleware/core"]
+  });
+}
+export {
+  getPackageJson as default
+};

package/dist/boilerplates/@batijs/d1/files/$wrangler.toml.js

@@ -12,6 +12,7 @@ binding = "DB" # Should match preview_database_id
 database_name = "YOUR_DATABASE_NAME"
 database_id = "the-id-of-your-D1-database-goes-here" # wrangler d1 info YOUR_DATABASE_NAME
 preview_database_id = "DB" # Required for Pages local development
+migrations_dir = "database/migrations"
 `;
   return `${content}
 ${dbSnippet}`;

package/dist/boilerplates/@batijs/d1/files/database/d1/helpers.ts

@@ -0,0 +1,17 @@
+import type { D1Database } from "@cloudflare/workers-types";
+import type { RuntimeAdapter } from "@universal-middleware/core";
+
+/**
+ * Retrieve Cloudflare `env.DB` from `universal-middleware` runtime
+ */
+export async function getDbFromRuntime(runtime: RuntimeAdapter): Promise<D1Database> {
+  if (runtime.runtime === "workerd") {
+    return runtime.env!.DB as D1Database;
+  }
+
+  // When running on node, simulate Cloudflare environment with "wrangler"
+  const { getPlatformProxy } = await import("wrangler");
+
+  const { env } = await getPlatformProxy();
+  return env.DB as D1Database;
+}

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

@@ -5,4 +5,12 @@ interface Env {
   DB: D1Database;
 }
 
+declare global {
+  namespace Vike {
+    interface PageContext {
+      env: Env;
+    }
+  }
+}
+
 export {};

package/dist/boilerplates/@batijs/d1/types/database/d1/helpers.d.ts

@@ -0,0 +1,6 @@
+import type { D1Database } from "@cloudflare/workers-types";
+import type { RuntimeAdapter } from "@universal-middleware/core";
+/**
+ * Retrieve Cloudflare `env.DB` from `universal-middleware` runtime
+ */
+export declare function getDbFromRuntime(runtime: RuntimeAdapter): Promise<D1Database>;

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

@@ -0,0 +1,10 @@
+// files/$package.json.ts
+import { loadAsJson } from "@batijs/core";
+async function getPackageJson(props) {
+  const packageJson = await loadAsJson(props);
+  packageJson.scripts["d1:migrate"] = "wrangler d1 migrations apply YOUR_DATABASE_NAME --local";
+  return packageJson;
+}
+export {
+  getPackageJson as default
+};

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

@@ -0,0 +1,28 @@
+import type { D1Database } from "@cloudflare/workers-types";
+
+export function getExistingUser<T>(db: D1Database, username: string) {
+  return db.prepare("SELECT * FROM users WHERE username = ?").bind(username).first<T>();
+}
+
+export function getExistingAccount<T>(db: D1Database, providerId: string, providerUserId: number) {
+  return db
+    .prepare("SELECT * FROM oauth_accounts WHERE provider_id = ? AND provider_user_id = ?")
+    .bind(providerId, providerUserId)
+    .first<T>();
+}
+
+export function signupWithGithub(db: D1Database, userId: string, username: string, githubUserId: number) {
+  return db.batch([
+    db.prepare("INSERT INTO users (id, username) VALUES (?, ?)").bind(userId, username),
+    db
+      .prepare("INSERT INTO oauth_accounts (provider_id, provider_user_id, user_id) VALUES (?, ?, ?)")
+      .bind("github", githubUserId, userId),
+  ]);
+}
+
+export function signupWithCredentials(db: D1Database, userId: string, username: string, passwordHash: string) {
+  return db
+    .prepare("INSERT INTO users (id, username, password) VALUES(?, ?, ?)")
+    .bind(userId, username, passwordHash)
+    .run();
+}

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

@@ -0,0 +1,10 @@
+import type { D1Database } from "@cloudflare/workers-types";
+
+export function insertTodo(db: D1Database, text: string) {
+  return db.prepare("INSERT INTO todos (text) VALUES (?)").bind(text).run();
+}
+
+export async function getAllTodos(db: D1Database) {
+  const { results } = await db.prepare("SELECT * FROM todos").all<{ id: number; text: string }>();
+  return results;
+}

package/dist/boilerplates/@batijs/d1-sqlite/files/database/migrations/lucia-auth.sql

@@ -0,0 +1,20 @@
+CREATE TABLE IF NOT EXISTS users (
+    id TEXT NOT NULL PRIMARY KEY,
+    username TEXT NOT NULL UNIQUE,
+    password TEXT
+);
+
+CREATE TABLE IF NOT EXISTS oauth_accounts (
+    provider_id TEXT NOT NULL,
+    provider_user_id INTEGER NOT NULL,
+    user_id TEXT NOT NULL,
+    PRIMARY KEY (provider_id, provider_user_id),
+    FOREIGN KEY (user_id) REFERENCES users(id) ON UPDATE cascade ON DELETE cascade
+);
+
+CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT NOT NULL PRIMARY KEY,
+    expires_at INTEGER NOT NULL,
+    user_id TEXT NOT NULL,
+    FOREIGN KEY (user_id) REFERENCES users(id) ON UPDATE cascade ON DELETE cascade
+);

package/dist/boilerplates/@batijs/d1-sqlite/files/database/migrations/todos.sql

@@ -0,0 +1,4 @@
+CREATE TABLE IF NOT EXISTS todos (
+    id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    text TEXT
+);

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

@@ -0,0 +1,5 @@
+import type { D1Database } from "@cloudflare/workers-types";
+export declare function getExistingUser<T>(db: D1Database, username: string): Promise<T | null>;
+export declare function getExistingAccount<T>(db: D1Database, providerId: string, providerUserId: number): Promise<T | null>;
+export declare function signupWithGithub(db: D1Database, userId: string, username: string, githubUserId: number): Promise<import("@cloudflare/workers-types").D1Result<unknown>[]>;
+export declare function signupWithCredentials(db: D1Database, userId: string, username: string, passwordHash: string): Promise<import("@cloudflare/workers-types").D1Result<Record<string, unknown>>>;

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

@@ -0,0 +1,6 @@
+import type { D1Database } from "@cloudflare/workers-types";
+export declare function insertTodo(db: D1Database, text: string): Promise<import("@cloudflare/workers-types").D1Result<Record<string, unknown>>>;
+export declare function getAllTodos(db: D1Database): Promise<{
+    id: number;
+    text: string;
+}[]>;

package/dist/boilerplates/@batijs/drizzle/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/drizzle/files/$README.md.js

@@ -9,15 +9,12 @@ First, ensure that \`DATABASE_URL\` is configured in \`.env\` file, then create
 \`\`\`bash
 pnpm drizzle:generate # a script that executes drizzle-kit generate.
 pnpm drizzle:migrate # a script that executes drizzle-kit migrate.
-pnpm drizzle:seed # a script that executes tsx ./database/drizzle/seed.ts.
 \`\`\`
 
 > [!NOTE]
 > The \`drizzle-kit generate\` command is used to generate SQL migration files based on your Drizzle schema.
 >
 > The \`drizzle-kit migrate\` command is used to apply the generated migrations to your database.
->
-> The \`tsx ./database/drizzle/seed.ts\` command is used to run a custom seed script to populate data to your database. 
 
 Read more on [Drizzle ORM documentation](https://orm.drizzle.team/docs/overview)
 `;

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

@@ -68,18 +68,15 @@ var require_package = __commonJS({
         "./database/drizzle/db": {
           types: "./dist/types/database/drizzle/db.d.ts"
         },
-        "./database/drizzle/schema/todos": {
-          types: "./dist/types/database/drizzle/schema/todos.d.ts"
-        },
-        "./database/drizzle/seed": {
-          types: "./dist/types/database/drizzle/seed.d.ts"
-        },
         "./database/drizzle/schema/lucia-auth": {
           types: "./dist/types/database/drizzle/schema/lucia-auth.d.ts"
         },
         "./database/drizzle/queries/lucia-auth": {
           types: "./dist/types/database/drizzle/queries/lucia-auth.d.ts"
         },
+        "./database/drizzle/schema/todos": {
+          types: "./dist/types/database/drizzle/schema/todos.d.ts"
+        },
         "./database/drizzle/queries/todos": {
           types: "./dist/types/database/drizzle/queries/todos.d.ts"
         }
@@ -92,18 +89,15 @@ var require_package = __commonJS({
           "database/drizzle/db": [
             "./dist/types/database/drizzle/db.d.ts"
           ],
-          "database/drizzle/schema/todos": [
-            "./dist/types/database/drizzle/schema/todos.d.ts"
-          ],
-          "database/drizzle/seed": [
-            "./dist/types/database/drizzle/seed.d.ts"
-          ],
           "database/drizzle/schema/lucia-auth": [
             "./dist/types/database/drizzle/schema/lucia-auth.d.ts"
           ],
           "database/drizzle/queries/lucia-auth": [
             "./dist/types/database/drizzle/queries/lucia-auth.d.ts"
           ],
+          "database/drizzle/schema/todos": [
+            "./dist/types/database/drizzle/schema/todos.d.ts"
+          ],
           "database/drizzle/queries/todos": [
             "./dist/types/database/drizzle/queries/todos.d.ts"
           ]
@@ -118,9 +112,8 @@ import { addDependency, loadAsJson } from "@batijs/core";
 async function getPackageJson(props) {
   const packageJson = await loadAsJson(props);
   packageJson.scripts["drizzle:generate"] = "drizzle-kit generate";
-  packageJson.scripts["drizzle:migrate"] = "drizzle-kit migrate";
+  packageJson.scripts["drizzle:migrate"] = props.meta.BATI.hasD1 ? "wrangler d1 migrations apply YOUR_DATABASE_NAME --local" : "drizzle-kit migrate";
   packageJson.scripts["drizzle:studio"] = "drizzle-kit studio";
-  packageJson.scripts["drizzle:seed"] = "tsx ./database/drizzle/seed.ts";
   return addDependency(packageJson, await Promise.resolve().then(() => __toESM(require_package(), 1)).then((x) => x.default), {
     devDependencies: ["@types/better-sqlite3", "tsx"],
     dependencies: ["better-sqlite3", "drizzle-kit", "drizzle-orm", "dotenv"]

package/dist/boilerplates/@batijs/drizzle/files/database/drizzle/db.ts

@@ -1,16 +1,14 @@
 import Database from "better-sqlite3";
-import { type BetterSQLite3Database, drizzle } from "drizzle-orm/better-sqlite3";
+import { drizzle as drizzleSqlite } from "drizzle-orm/better-sqlite3";
+import { drizzle as drizzleD1 } from "drizzle-orm/d1";
 
-let singleton: BetterSQLite3Database | undefined = undefined;
-
-export function db() {
-  if (!singleton) {
-    if (!process.env.DATABASE_URL) {
-      throw new Error("Missing DATABASE_URL in .env file");
-    }
+//# !BATI.hasD1
+export function dbSqlite() {
+  const sqlite = new Database(process.env.DATABASE_URL);
+  return drizzleSqlite(sqlite);
+}
 
-    const sqlite = new Database(process.env.DATABASE_URL);
-    singleton = drizzle(sqlite);
-  }
-  return singleton;
+//# BATI.hasD1
+export function dbD1(d1: D1Database) {
+  return drizzleD1(d1);
 }

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

@@ -1,27 +1,56 @@
 /*# BATI include-if-imported #*/
-import { db } from "../db";
+import { dbD1, dbSqlite } from "../db";
 import { oauthAccountTable, userTable } from "../schema/lucia-auth";
 import { and, eq } from "drizzle-orm";
 
-export function getExistingUser(username: string) {
-  return db().select().from(userTable).where(eq(userTable.username, username)).get();
+export async function getExistingUser(
+  db: BATI.If<{
+    "!BATI.hasD1": ReturnType<typeof dbSqlite>;
+    _: ReturnType<typeof dbD1>;
+  }>,
+  username: string,
+) {
+  return db.select().from(userTable).where(eq(userTable.username, username)).get();
 }
 
-export function getExistingAccount(providerId: string, providerUserId: number) {
-  return db()
+export async function getExistingAccount(
+  db: BATI.If<{
+    "!BATI.hasD1": ReturnType<typeof dbSqlite>;
+    _: ReturnType<typeof dbD1>;
+  }>,
+  providerId: string,
+  providerUserId: number,
+) {
+  return db
     .select()
     .from(oauthAccountTable)
     .where(and(eq(oauthAccountTable.providerId, providerId), eq(oauthAccountTable.providerUserId, providerUserId)))
     .get();
 }
 
-export function signupWithGithub(userId: string, username: string, githubUserId: number) {
-  return db().transaction(async (tx) => {
+export async function signupWithGithub(
+  db: BATI.If<{
+    "!BATI.hasD1": ReturnType<typeof dbSqlite>;
+    _: ReturnType<typeof dbD1>;
+  }>,
+  userId: string,
+  username: string,
+  githubUserId: number,
+) {
+  return db.transaction(async (tx) => {
     await tx.insert(userTable).values({ id: userId, username: username });
     await tx.insert(oauthAccountTable).values({ providerId: "github", providerUserId: githubUserId, userId });
   });
 }
 
-export function signupWithCredentials(userId: string, username: string, passwordHash: string) {
-  return db().insert(userTable).values({ id: userId, username, password: passwordHash }).run();
+export async function signupWithCredentials(
+  db: BATI.If<{
+    "!BATI.hasD1": ReturnType<typeof dbSqlite>;
+    _: ReturnType<typeof dbD1>;
+  }>,
+  userId: string,
+  username: string,
+  passwordHash: string,
+) {
+  return db.insert(userTable).values({ id: userId, username, password: passwordHash }).run();
 }

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

@@ -1,11 +1,22 @@
 /*# BATI include-if-imported #*/
-import { db } from "../db";
 import { todoTable } from "../schema/todos";
+import { dbD1, type dbSqlite } from "../db";
 
-export function insertTodo(text: string) {
-  return db().insert(todoTable).values({ text });
+export function insertTodo(
+  db: BATI.If<{
+    "!BATI.hasD1": ReturnType<typeof dbSqlite>;
+    _: ReturnType<typeof dbD1>;
+  }>,
+  text: string,
+) {
+  return db.insert(todoTable).values({ text });
 }
 
-export function getAllTodos() {
-  return db().select().from(todoTable).all();
+export function getAllTodos(
+  db: BATI.If<{
+    "!BATI.hasD1": ReturnType<typeof dbSqlite>;
+    _: ReturnType<typeof dbD1>;
+  }>,
+) {
+  return db.select().from(todoTable).all();
 }

package/dist/boilerplates/@batijs/drizzle/files/drizzle.config.ts

@@ -1,14 +1,17 @@
 import { defineConfig } from "drizzle-kit";
 
-if (!process.env.DATABASE_URL) {
-  throw new Error("Missing DATABASE_URL in .env file");
+if (!BATI.hasD1) {
+  if (!process.env.DATABASE_URL) {
+    throw new Error("Missing DATABASE_URL in .env file");
+  }
 }
 
 export default defineConfig({
   dialect: "sqlite",
   schema: "./database/drizzle/schema/*",
-  out: "./database/drizzle/migrations",
+  out: "./database/migrations",
+  //# !BATI.hasD1
   dbCredentials: {
-    url: process.env.DATABASE_URL,
+    url: process.env.DATABASE_URL!,
   },
 });