@batijs/cli 0.0.644 → 0.0.647

package/dist/{asset-package.json-Oy4M8AmU.js → asset-package.json-45oDzgS0.js}

@@ -17,6 +17,7 @@ var package_default = {
 	devDependencies: {
 		"@auth/core": "^0.41.2",
 		"@batijs/authjs": "workspace:*",
+		"@batijs/better-auth": "workspace:*",
 		"@batijs/compile": "workspace:*",
 		"@batijs/core": "workspace:*",
 		"@batijs/shared-db": "workspace:*",

package/dist/{asset-package.json-D6e6vjLM.js → asset-package.json-C4csvBBQ.js}

@@ -17,6 +17,7 @@ var package_default = {
 	devDependencies: {
 		"@auth/core": "^0.41.2",
 		"@batijs/authjs": "workspace:*",
+		"@batijs/better-auth": "workspace:*",
 		"@batijs/compile": "workspace:*",
 		"@batijs/core": "workspace:*",
 		"@batijs/shared-db": "workspace:*",

package/dist/{asset-package.json-DsPzKJwr.js → asset-package.json-CDq-96lS.js}

@@ -17,6 +17,7 @@ var package_default = {
 	devDependencies: {
 		"@auth/core": "^0.41.2",
 		"@batijs/authjs": "workspace:*",
+		"@batijs/better-auth": "workspace:*",
 		"@batijs/compile": "workspace:*",
 		"@batijs/core": "workspace:*",
 		"@batijs/shared-db": "workspace:*",

package/dist/{asset-package.json-BBHKZA3A.js → asset-package.json-C_aGwesI.js}

@@ -18,6 +18,7 @@ var package_default = {
 		"@batijs/compile": "workspace:*",
 		"@batijs/core": "workspace:*",
 		"@batijs/shared-todo": "workspace:*",
+		"@batijs/solid-better-auth": "workspace:*",
 		"@batijs/telefunc": "workspace:*",
 		"@batijs/trpc": "workspace:*",
 		"@batijs/ts-rest": "workspace:*",

package/dist/asset-package.json-D0EjbpfM.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+//#region ../../boilerplates/better-auth/dist/files/asset-package.json.mjs
+var package_default = {
+	name: "@batijs/better-auth",
+	"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:*",
+		"@batijs/core": "workspace:*",
+		"@batijs/drizzle": "workspace:*",
+		"@types/better-sqlite3": "^7.6.13",
+		"@types/node": "^20.19.37",
+		"@universal-middleware/core": "^0.4.17",
+		"better-sqlite3": "^12.10.0",
+		"drizzle-orm": "^0.45.2",
+		"dotenv": "^17.4.2",
+		"kysely": "^0.29.2",
+		"kysely-d1": "^0.4.0",
+		"kysely-postgres-js": "^3.0.0",
+		"postgres": "^3.4.9",
+		"tsx": "^4.22.4"
+	},
+	dependencies: { "better-auth": "^1.6.15" },
+	files: ["dist/"],
+	exports: {
+		"./database/better-auth/migrate": { "types": "./dist/types/database/better-auth/migrate.d.mts" },
+		"./database/drizzle/schema/auth": { "types": "./dist/types/database/drizzle/schema/auth.d.mts" },
+		"./server/better-auth": { "types": "./dist/types/server/better-auth.d.mts" },
+		"./server/better-auth-handler": { "types": "./dist/types/server/better-auth-handler.d.mts" }
+	},
+	typesVersions: { "*": {
+		"database/better-auth/migrate": ["./dist/types/database/better-auth/migrate.d.mts"],
+		"database/drizzle/schema/auth": ["./dist/types/database/drizzle/schema/auth.d.mts"],
+		"server/better-auth": ["./dist/types/server/better-auth.d.mts"],
+		"server/better-auth-handler": ["./dist/types/server/better-auth-handler.d.mts"]
+	} },
+	nx: { "tags": ["type:boilerplate"] }
+};
+//#endregion
+export { package_default as default };

package/dist/{asset-package.json-DUzfK1ah.js → asset-package.json-DRdzE2Je.js}

@@ -17,6 +17,7 @@ var package_default = {
 	devDependencies: {
 		"@auth/core": "^0.41.2",
 		"@batijs/authjs": "workspace:*",
+		"@batijs/better-auth": "workspace:*",
 		"@batijs/compile": "workspace:*",
 		"@batijs/core": "workspace:*",
 		"@batijs/shared-db": "workspace:*",

package/dist/{asset-package.json-c4TM2QxI.js → asset-package.json-IZ_nF8HA.js}

@@ -20,6 +20,7 @@ var package_default = {
 		"@babel/plugin-transform-react-jsx": "^7.29.7",
 		"@batijs/compile": "workspace:*",
 		"@batijs/core": "workspace:*",
+		"@batijs/react-better-auth": "workspace:*",
 		"@batijs/shared-todo": "workspace:*",
 		"@batijs/telefunc": "workspace:*",
 		"@batijs/trpc": "workspace:*",

package/dist/boilerplates/@batijs/better-auth/bati.config.mjs

@@ -0,0 +1,48 @@
+//#region ../../packages/core/dist/config.js
+function e(e, t) {
+	if (!e) throw Error(t);
+}
+function t(t) {
+	return `enforce` in t && e(t.enforce === `pre` || t.enforce === `post`, `'enforce' must be 'pre' or 'post', was ${t.enforce}`), `if` in t && e(typeof t.if == `function`, `'if' must be a function`), `nextSteps` in t && e(typeof t.nextSteps == `function`, `'nextSteps' must be a function`), `knip` in t && (e(typeof t.knip == `object` && t.knip !== null, `'knip' must be an object`), `entry` in t.knip && e(Array.isArray(t.knip.entry), `'knip.entry' must be an array`), `ignoreDependencies` in t.knip && e(Array.isArray(t.knip.ignoreDependencies), `'knip.ignoreDependencies' must be an array`), `ignore` in t.knip && e(Array.isArray(t.knip.ignore), `'knip.ignore' must be an array`), `vite` in t.knip && e(typeof t.knip.vite == `boolean`, `'knip.vite' must be a boolean`)), `env` in t && e(typeof t.env == `function`, `'env' must be a function of meta`), t;
+}
+//#endregion
+//#region bati.config.ts
+var bati_config_default = t({
+	if(meta) {
+		return meta.BATI.has("better-auth");
+	},
+	env: () => [
+		{
+			key: "BETTER_AUTH_SECRET",
+			scope: "server-default",
+			default: "dev-secret-please-change-me-in-production",
+			comment: "Better Auth secret used to sign cookies and tokens — replace in production. See https://better-auth.com/docs/reference/options#secret"
+		},
+		{
+			key: "GITHUB_CLIENT_ID",
+			scope: "secret",
+			comment: "GitHub OAuth Client ID",
+			devValueFrom: "TEST_GITHUB_CLIENT_ID",
+			group: "github"
+		},
+		{
+			key: "GITHUB_CLIENT_SECRET",
+			scope: "secret",
+			comment: "GitHub OAuth Client Secret",
+			devValueFrom: "TEST_GITHUB_CLIENT_SECRET",
+			group: "github"
+		}
+	],
+	nextSteps(meta, packageManager, { bold }) {
+		return [...meta.BATI.hasD1 || meta.BATI.has("drizzle") ? [] : [{
+			type: "command",
+			step: `${packageManager} better-auth:migrate`
+		}], {
+			type: "text",
+			step: `Configure Better Auth (secret, GitHub OAuth, migrations). Check ${bold("TODO.md")} for details`
+		}];
+	},
+	knip: { entry: ["server/better-auth-handler.ts", "database/better-auth/migrate.ts"] }
+});
+//#endregion
+export { bati_config_default as default };

package/dist/boilerplates/@batijs/better-auth/files/$TODO.md.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+import { loadMarkdown, packageManager } from "@batijs/core";
+//#region ../../boilerplates/better-auth/dist/files/$TODO.md.mjs
+async function getTodo(props) {
+	const content = await loadMarkdown(props);
+	const pmRun = packageManager().run;
+	const { BATI } = props.meta;
+	const todo = `
+## Better Auth
+
+Pages are scaffolded at \`/login\`, \`/signup\` and \`/account\` (the latter is protected and redirects to \`/login\`).
+
+1. Replace \`BETTER_AUTH_SECRET\` in your \`.env\` with a strong, unique value before going to production — see <https://better-auth.com/docs/reference/options#secret>.
+2. ${BATI.has("drizzle") ? `Create Better Auth's tables — they live in your Drizzle schema (\`database/drizzle/schema/auth.ts\`), so the Drizzle migrate steps create them.` : BATI.hasD1 ? `Create Better Auth's tables in your D1 database. Generate the SQL with \`npx @better-auth/cli generate\` and apply it as a [wrangler D1 migration](https://developers.cloudflare.com/d1/reference/migrations/).` : `Create Better Auth's tables (run again whenever the schema changes):
+\`\`\`sh
+${pmRun} better-auth:migrate
+\`\`\``}
+3. (Optional) Enable GitHub sign-in: create a GitHub OAuth app (<https://github.com/settings/developers>), set the callback URL to \`<your-app-url>/api/auth/callback/github\`, and fill \`GITHUB_CLIENT_ID\` / \`GITHUB_CLIENT_SECRET\` in your \`.env\`. The button is hidden until both are set.
+
+See <https://better-auth.com/docs> for adding more providers and plugins.`;
+	content.addMarkdownFeature(todo, "better-auth");
+	return content;
+}
+//#endregion
+export { getTodo as default };

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

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import { loadPackageJson, packageManager } from "@batijs/core";
+//#region ../../boilerplates/better-auth/dist/files/$package.json.mjs
+async function getPackageJson(props) {
+	const packageJson = await loadPackageJson(props, await import("../../../../asset-package.json-D0EjbpfM.js").then((x) => x.default));
+	const { BATI } = props.meta;
+	packageJson.addDependencies(["better-auth", "@universal-middleware/core"]);
+	if (BATI.has("drizzle")) return packageJson;
+	if (BATI.hasD1) return packageJson.addDependencies(["kysely", "kysely-d1"]);
+	const hasPostgres = BATI.has("postgres");
+	const bunDirect = packageManager().name === "bun" && hasPostgres;
+	return packageJson.setScript("better-auth:migrate", {
+		value: `${bunDirect ? "bun" : "tsx"} ./database/better-auth/migrate.ts`,
+		precedence: 20
+	}).addDevDependencies(["tsx"], ["better-auth:migrate"], !bunDirect).addDependencies(["dotenv"]).addDependencies([
+		"postgres",
+		"kysely",
+		"kysely-postgres-js"
+	], hasPostgres).addDependencies(["better-sqlite3"], !hasPostgres).addDevDependencies(["@types/better-sqlite3"], !hasPostgres);
+}
+//#endregion
+export { getPackageJson as default };

package/dist/boilerplates/@batijs/better-auth/files/asset-package.json.mjs

@@ -0,0 +1,48 @@
+//#region package.json
+var package_default = {
+	name: "@batijs/better-auth",
+	"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:*",
+		"@batijs/core": "workspace:*",
+		"@batijs/drizzle": "workspace:*",
+		"@types/better-sqlite3": "^7.6.13",
+		"@types/node": "^20.19.37",
+		"@universal-middleware/core": "^0.4.17",
+		"better-sqlite3": "^12.10.0",
+		"drizzle-orm": "^0.45.2",
+		"dotenv": "^17.4.2",
+		"kysely": "^0.29.2",
+		"kysely-d1": "^0.4.0",
+		"kysely-postgres-js": "^3.0.0",
+		"postgres": "^3.4.9",
+		"tsx": "^4.22.4"
+	},
+	dependencies: { "better-auth": "^1.6.15" },
+	files: ["dist/"],
+	exports: {
+		"./database/better-auth/migrate": { "types": "./dist/types/database/better-auth/migrate.d.mts" },
+		"./database/drizzle/schema/auth": { "types": "./dist/types/database/drizzle/schema/auth.d.mts" },
+		"./server/better-auth": { "types": "./dist/types/server/better-auth.d.mts" },
+		"./server/better-auth-handler": { "types": "./dist/types/server/better-auth-handler.d.mts" }
+	},
+	typesVersions: { "*": {
+		"database/better-auth/migrate": ["./dist/types/database/better-auth/migrate.d.mts"],
+		"database/drizzle/schema/auth": ["./dist/types/database/drizzle/schema/auth.d.mts"],
+		"server/better-auth": ["./dist/types/server/better-auth.d.mts"],
+		"server/better-auth-handler": ["./dist/types/server/better-auth-handler.d.mts"]
+	} },
+	nx: { "tags": ["type:boilerplate"] }
+};
+//#endregion
+export { package_default as default };

package/dist/boilerplates/@batijs/better-auth/files/database/better-auth/migrate.ts

@@ -0,0 +1,20 @@
+/*{ @if (!it.BATI.hasD1 && !it.BATI.has("drizzle")) }*/
+
+import "dotenv/config";
+import { getMigrations } from "better-auth/db/migration";
+import { getAuthConfig } from "../../server/better-auth";
+
+// Creates / updates Better Auth's tables (`user`, `session`, `account`, `verification`) using its
+// built-in Kysely adapter. Run with `better-auth:migrate`.
+// Note: with Drizzle or on Cloudflare D1 this script is not generated — Drizzle's schema or a wrangler
+// D1 migration creates the tables instead.
+const { runMigrations } = await getMigrations(getAuthConfig());
+
+await runMigrations();
+
+console.log("Better Auth tables are up to date");
+
+// The database driver keeps the event loop alive (e.g. Postgres connection pool); exit explicitly
+// so this one-shot script terminates instead of hanging.
+process.exit(0);
+/*{ /if }*/

package/dist/boilerplates/@batijs/better-auth/files/database/drizzle/schema/auth.ts

@@ -0,0 +1,99 @@
+/*# BATI include-if-imported #*/
+import { boolean, pgTable, text as pgText, timestamp } from "drizzle-orm/pg-core";
+import { integer, sqliteTable, text as sqliteText } from "drizzle-orm/sqlite-core";
+
+// Better Auth's tables, owned by Drizzle so its migrations create them.
+// Regenerate with `npx @better-auth/cli generate` if you customize the Better Auth config.
+// Column names are snake_case to match Better Auth's Drizzle adapter defaults.
+
+export const user = BATI.has("postgres")
+  ? pgTable("user", {
+      id: pgText("id").primaryKey(),
+      name: pgText("name").notNull(),
+      email: pgText("email").notNull().unique(),
+      emailVerified: boolean("email_verified").notNull(),
+      image: pgText("image"),
+      createdAt: timestamp("created_at").notNull(),
+      updatedAt: timestamp("updated_at").notNull(),
+    })
+  : sqliteTable("user", {
+      id: sqliteText("id").primaryKey(),
+      name: sqliteText("name").notNull(),
+      email: sqliteText("email").notNull().unique(),
+      emailVerified: integer("email_verified", { mode: "boolean" }).notNull(),
+      image: sqliteText("image"),
+      createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+      updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull(),
+    });
+
+export const session = BATI.has("postgres")
+  ? pgTable("session", {
+      id: pgText("id").primaryKey(),
+      expiresAt: timestamp("expires_at").notNull(),
+      token: pgText("token").notNull().unique(),
+      createdAt: timestamp("created_at").notNull(),
+      updatedAt: timestamp("updated_at").notNull(),
+      ipAddress: pgText("ip_address"),
+      userAgent: pgText("user_agent"),
+      userId: pgText("user_id").notNull(),
+    })
+  : sqliteTable("session", {
+      id: sqliteText("id").primaryKey(),
+      expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull(),
+      token: sqliteText("token").notNull().unique(),
+      createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+      updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull(),
+      ipAddress: sqliteText("ip_address"),
+      userAgent: sqliteText("user_agent"),
+      userId: sqliteText("user_id").notNull(),
+    });
+
+export const account = BATI.has("postgres")
+  ? pgTable("account", {
+      id: pgText("id").primaryKey(),
+      accountId: pgText("account_id").notNull(),
+      providerId: pgText("provider_id").notNull(),
+      userId: pgText("user_id").notNull(),
+      accessToken: pgText("access_token"),
+      refreshToken: pgText("refresh_token"),
+      idToken: pgText("id_token"),
+      accessTokenExpiresAt: timestamp("access_token_expires_at"),
+      refreshTokenExpiresAt: timestamp("refresh_token_expires_at"),
+      scope: pgText("scope"),
+      password: pgText("password"),
+      createdAt: timestamp("created_at").notNull(),
+      updatedAt: timestamp("updated_at").notNull(),
+    })
+  : sqliteTable("account", {
+      id: sqliteText("id").primaryKey(),
+      accountId: sqliteText("account_id").notNull(),
+      providerId: sqliteText("provider_id").notNull(),
+      userId: sqliteText("user_id").notNull(),
+      accessToken: sqliteText("access_token"),
+      refreshToken: sqliteText("refresh_token"),
+      idToken: sqliteText("id_token"),
+      accessTokenExpiresAt: integer("access_token_expires_at", { mode: "timestamp_ms" }),
+      refreshTokenExpiresAt: integer("refresh_token_expires_at", { mode: "timestamp_ms" }),
+      scope: sqliteText("scope"),
+      password: sqliteText("password"),
+      createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+      updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull(),
+    });
+
+export const verification = BATI.has("postgres")
+  ? pgTable("verification", {
+      id: pgText("id").primaryKey(),
+      identifier: pgText("identifier").notNull(),
+      value: pgText("value").notNull(),
+      expiresAt: timestamp("expires_at").notNull(),
+      createdAt: timestamp("created_at").notNull(),
+      updatedAt: timestamp("updated_at").notNull(),
+    })
+  : sqliteTable("verification", {
+      id: sqliteText("id").primaryKey(),
+      identifier: sqliteText("identifier").notNull(),
+      value: sqliteText("value").notNull(),
+      expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull(),
+      createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+      updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull(),
+    });

package/dist/boilerplates/@batijs/better-auth/files/database/migrations/$better-auth.sql.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+//#region ../../boilerplates/better-auth/dist/files/database/migrations/$better-auth.sql.mjs
+function getMigration(props) {
+	if (!props.meta.BATI.hasD1 || props.meta.BATI.has("drizzle")) return void 0;
+	return `CREATE TABLE IF NOT EXISTS "user" (
+  "id" text NOT NULL PRIMARY KEY,
+  "name" text NOT NULL,
+  "email" text NOT NULL UNIQUE,
+  "emailVerified" integer NOT NULL DEFAULT 0,
+  "image" text,
+  "createdAt" date NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "updatedAt" date NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS "session" (
+  "id" text NOT NULL PRIMARY KEY,
+  "expiresAt" date NOT NULL,
+  "token" text NOT NULL UNIQUE,
+  "createdAt" date NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "updatedAt" date NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "ipAddress" text,
+  "userAgent" text,
+  "userId" text NOT NULL REFERENCES "user" ("id")
+);
+
+CREATE TABLE IF NOT EXISTS "account" (
+  "id" text NOT NULL PRIMARY KEY,
+  "accountId" text NOT NULL,
+  "providerId" text NOT NULL,
+  "userId" text NOT NULL REFERENCES "user" ("id"),
+  "accessToken" text,
+  "refreshToken" text,
+  "idToken" text,
+  "accessTokenExpiresAt" date,
+  "refreshTokenExpiresAt" date,
+  "scope" text,
+  "password" text,
+  "createdAt" date NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "updatedAt" date NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS "verification" (
+  "id" text NOT NULL PRIMARY KEY,
+  "identifier" text NOT NULL,
+  "value" text NOT NULL,
+  "expiresAt" date NOT NULL,
+  "createdAt" date DEFAULT CURRENT_TIMESTAMP,
+  "updatedAt" date DEFAULT CURRENT_TIMESTAMP
+);
+`;
+}
+//#endregion
+export { getMigration as default };

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

@@ -0,0 +1,67 @@
+import {
+  enhance,
+  type RuntimeAdapter,
+  type UniversalHandler,
+  type UniversalMiddleware,
+} from "@universal-middleware/core";
+import { betterAuth } from "better-auth";
+import { getAuthConfig } from "./better-auth";
+
+//# !BATI.hasD1
+let authSingleton: ReturnType<typeof betterAuth> | undefined;
+
+// On Cloudflare the D1 binding is request-scoped (fresh instance per request); elsewhere it's memoized.
+function getAuth(runtime: RuntimeAdapter) {
+  if (BATI.hasD1) {
+    return betterAuth(getAuthConfig(runtime));
+  } else {
+    authSingleton ??= betterAuth(getAuthConfig(runtime));
+    return authSingleton;
+  }
+}
+
+// Note: You can directly define a server middleware instead of defining a Universal Middleware. (You can remove @universal-middleware/* — Vike's scaffolder uses it only to simplify its internal logic, see https://github.com/vikejs/vike/discussions/3116)
+/**
+ * Add the Better Auth user to the context.
+ * @link {@see https://better-auth.com/docs/concepts/session-management}
+ */
+export const betterAuthSessionMiddleware: UniversalMiddleware = enhance(
+  // The context we add here is automatically merged into pageContext
+  async (request, context, runtime) => {
+    try {
+      const data = await getAuth(runtime).api.getSession({ headers: request.headers });
+      return {
+        ...context,
+        // Sets pageContext.user
+        user: data?.user ?? null,
+      };
+    } catch (error) {
+      console.debug("betterAuthSessionMiddleware:", error);
+      return {
+        ...context,
+        user: null,
+      };
+    }
+  },
+  {
+    name: "my-app:better-auth-middleware",
+    immutable: false,
+  },
+);
+
+// Note: You can directly define a server middleware instead of defining a Universal Middleware. (You can remove @universal-middleware/* — Vike's scaffolder uses it only to simplify its internal logic, see https://github.com/vikejs/vike/discussions/3116)
+/**
+ * Better Auth route
+ * @link {@see https://better-auth.com/docs/installation}
+ **/
+export const betterAuthHandler = enhance(
+  async (request, _context, runtime) => {
+    return getAuth(runtime).handler(request);
+  },
+  {
+    name: "my-app:better-auth-handler",
+    path: "/api/auth/**",
+    method: ["GET", "POST"],
+    immutable: false,
+  },
+) satisfies UniversalHandler;

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

@@ -0,0 +1,89 @@
+import { env as cloudflareEnv } from "cloudflare:workers";
+import { dbD1, dbPostgres, dbSqlite } from "@batijs/drizzle/database/drizzle/db";
+import type { RuntimeAdapter } from "@universal-middleware/core";
+import type { BetterAuthOptions } from "better-auth";
+import { drizzleAdapter } from "better-auth/adapters/drizzle";
+import Database from "better-sqlite3";
+import { Kysely } from "kysely";
+import { D1Dialect } from "kysely-d1";
+import { PostgresJSDialect } from "kysely-postgres-js";
+import postgres from "postgres";
+import * as authSchema from "../database/drizzle/schema/auth";
+
+const env: BATI.If<{ '!BATI.has("cloudflare")': Record<string, string | undefined> }> = BATI.has("cloudflare")
+  ? (cloudflareEnv as BATI.Any)
+  : typeof process?.env !== "undefined"
+    ? process.env
+    : {};
+
+//# BATI.hasD1
+function getD1(runtime?: RuntimeAdapter): D1Database {
+  if (runtime?.runtime === "workerd" && runtime.env) {
+    return runtime.env.DB as D1Database;
+  }
+  throw new Error("Cloudflare D1 binding (DB) is not available");
+}
+
+//# BATI.has("drizzle")
+function getDrizzleDb(_runtime?: RuntimeAdapter) {
+  if (BATI.hasD1) {
+    return dbD1(getD1(_runtime));
+  } else if (BATI.has("postgres")) {
+    return dbPostgres();
+  } else {
+    return dbSqlite();
+  }
+}
+
+// Better Auth keeps its own tables (user/session/account/verification) so it only needs the engine.
+// With Drizzle it reuses the app's instance (Drizzle owns the schema + migrations); otherwise it
+// opens its own connection and creates the tables via `better-auth:migrate` (or a D1 SQL migration).
+function getDatabase(_runtime?: RuntimeAdapter): BetterAuthOptions["database"] {
+  if (BATI.has("drizzle")) {
+    return drizzleAdapter(getDrizzleDb(_runtime), {
+      provider: BATI.has("postgres") ? "pg" : "sqlite",
+      schema: authSchema,
+    });
+  } else if (BATI.hasD1) {
+    // Cloudflare D1 is the SQLite engine on Workers, reached through Kysely's D1 dialect.
+    return {
+      db: new Kysely({ dialect: new D1Dialect({ database: getD1(_runtime) }) }),
+      type: "sqlite" as const,
+    };
+  } else if (BATI.has("postgres")) {
+    // postgres.js via Kysely's dialect — the same driver the rest of the app uses (and Bun-friendly).
+    if (!env.DATABASE_URL) {
+      throw new Error("Missing DATABASE_URL in .env file");
+    }
+    return {
+      db: new Kysely({ dialect: new PostgresJSDialect({ postgres: postgres(env.DATABASE_URL) }) }),
+      type: "postgres" as const,
+    };
+  } else {
+    // SQLite via better-sqlite3. Prisma-style `file:` URLs are normalized to a plain path.
+    if (!env.DATABASE_URL) {
+      throw new Error("Missing DATABASE_URL in .env file");
+    }
+    return new Database(env.DATABASE_URL.replace(/^file:/, ""));
+  }
+}
+
+export function getAuthConfig(runtime?: RuntimeAdapter): BetterAuthOptions {
+  return {
+    secret: env.BETTER_AUTH_SECRET,
+    database: getDatabase(runtime),
+    emailAndPassword: {
+      enabled: true,
+    },
+    // GitHub is only enabled once its credentials are set, so the app runs out of the box without them.
+    socialProviders:
+      env.GITHUB_CLIENT_ID && env.GITHUB_CLIENT_SECRET
+        ? {
+            github: {
+              clientId: env.GITHUB_CLIENT_ID,
+              clientSecret: env.GITHUB_CLIENT_SECRET,
+            },
+          }
+        : {},
+  };
+}

package/dist/boilerplates/@batijs/better-auth/types/database/better-auth/migrate.d.mts

@@ -0,0 +1 @@
+export { };