feat: postgres

.github/workflows/reusable.run-tests.yml

@@ -132,6 +132,22 @@ jobs:
         run: bun run build
         working-directory: ${{ runner.temp }}/${{ inputs.destination }}
 
+      # PostgreSQL-backed apps connect to the default DATABASE_URL
+      # (postgresql://postgres:postgres@localhost:5432/app). Spin up a matching server.
+      - name: Start PostgreSQL
+        if: contains(inputs.flags, '--postgres')
+        shell: bash
+        run: |
+          docker run -d --name bati-postgres \
+            -e POSTGRES_USER=postgres -e POSTGRES_PASSWORD=postgres -e POSTGRES_DB=app \
+            -p 5432:5432 postgres:18-alpine
+          for i in $(seq 1 30); do
+            if docker exec bati-postgres pg_isready -U postgres -d app >/dev/null 2>&1; then
+              echo "PostgreSQL is ready"; break
+            fi
+            sleep 1
+          done
+
       - name: Run tests
         shell: bash
         # Bun hangs on Windows

boilerplates/d1-sqlite/bati.config.ts

@@ -2,6 +2,7 @@ import { defineConfig } from "@batijs/core/config";
 
 export default defineConfig({
   if(meta) {
-    return meta.BATI.hasD1 && meta.BATI.has("sqlite");
+    // Raw D1 queries: the SQLite engine on Cloudflare with no ORM/query builder.
+    return meta.BATI.hasD1 && !meta.BATI.hasOrm;
   },
 });

boilerplates/docker-compose/env.spec.ts

@@ -17,9 +17,9 @@ const registry: EnvRegistry = [
 ];
 
 describe("composeEnvEntries", () => {
-  test("secrets pull from host, defaulted vars are host-overridable, public is omitted", () => {
+  test("secrets pull from host, defaulted vars are pinned to their compose value, public is omitted", () => {
     expect(composeEnvEntries(registry)).toEqual([
-      "DATABASE_URL=${DATABASE_URL:-/app/data/db.sqlite}",
+      "DATABASE_URL=/app/data/db.sqlite",
       "AUTH0_CLIENT_ID=${AUTH0_CLIENT_ID}",
       "SENTRY_DSN=${SENTRY_DSN}",
     ]);

boilerplates/docker-compose/env.ts

@@ -2,16 +2,17 @@ import { committedValue, type EnvRecord, type EnvRegistry, isServerVar } from "@
 
 /**
  * `KEY=<expr>` lines for the docker-compose `services.<app>.environment` list:
- * secrets are pulled from the host (`${KEY}`), defaulted vars are host-overridable
- * (`${KEY:-<default>}`).
+ * secrets are pulled from the host (`${KEY}`); defaulted vars are pinned to their
+ * compose value. Pinning (not `${KEY:-default}`) is deliberate: compose loads the
+ * project `.env` for interpolation, and `.env` carries the local-dev value (e.g.
+ * `DATABASE_URL` on `localhost`), which would otherwise shadow the in-container
+ * value (the app reaching the `postgres` service over the compose network).
  */
 export function composeEnvEntries(registry: EnvRegistry): string[] {
   return registry
     .filter(isServerVar)
     .map((def) =>
-      def.scope === "secret"
-        ? `${def.key}=\${${def.key}}`
-        : `${def.key}=\${${def.key}:-${committedValue(def, "compose")}}`,
+      def.scope === "secret" ? `${def.key}=\${${def.key}}` : `${def.key}=${committedValue(def, "compose")}`,
     );
 }
 

boilerplates/docker-compose/files/$Dockerfile.ts

@@ -21,10 +21,8 @@ export default async function getDockerfile(props: TransformerProps): Promise<st
   // migrating — plus the source files each migration script must find in the runner.
   const startupMigrations: string[] = [];
   const migrationCopies: { sources: string[]; dest: string; from: string }[] = [];
-  if (meta.BATI.has("sqlite")) {
-    startupMigrations.push(`${run} sqlite:migrate`);
-    migrationCopies.push({ sources: ["/app/database/sqlite"], dest: "./database/sqlite", from: "builder" });
-  }
+  // Each ORM owns its migration; the raw-client engines (sqlite/postgres) run their
+  // own schema script, and only when no ORM is selected (Prisma is self-managed too).
   if (meta.BATI.has("drizzle")) {
     startupMigrations.push(`${run} drizzle:migrate`);
     migrationCopies.push({ sources: ["/app/database/migrations"], dest: "./database/migrations", from: "deps-dev" });
@@ -38,6 +36,14 @@ export default async function getDockerfile(props: TransformerProps): Promise<st
       from: "builder",
     });
   }
+  if (meta.BATI.has("sqlite") && !meta.BATI.hasOrm) {
+    startupMigrations.push(`${run} sqlite:migrate`);
+    migrationCopies.push({ sources: ["/app/database/sqlite"], dest: "./database/sqlite", from: "builder" });
+  }
+  if (meta.BATI.has("postgres") && !meta.BATI.hasOrm) {
+    startupMigrations.push(`${run} postgres:migrate`);
+    migrationCopies.push({ sources: ["/app/database/postgres"], dest: "./database/postgres", from: "builder" });
+  }
 
   // Run migrations before the server when present; otherwise launch it directly.
   const startCmd =

boilerplates/docker-compose/files/docker-compose.yml

@@ -8,11 +8,34 @@ services:
     environment:
       - NODE_ENV=production
       - PORT=3000
-    # BATI.hasDatabase
+    # BATI.hasDatabase && !BATI.has("postgres")
     volumes:
       - sqlite_data:/app/data
+    # BATI.has("postgres")
+    depends_on:
+      postgres:
+        condition: service_healthy
+    restart: unless-stopped
+
+  # BATI.has("postgres")
+  postgres:
+    image: postgres:18-alpine
+    environment:
+      - POSTGRES_USER=${POSTGRES_USER:-postgres}
+      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-postgres}
+      - POSTGRES_DB=${POSTGRES_DB:-app}
+    volumes:
+      - postgres_data:/var/lib/postgresql
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-postgres} -d ${POSTGRES_DB:-app}"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
     restart: unless-stopped
 
 # BATI.hasDatabase
 volumes:
-  sqlite_data:
+  # BATI.hasDatabase && !BATI.has("postgres")
+  sqlite_data: {}
+  # BATI.has("postgres")
+  postgres_data: {}

boilerplates/drizzle/files/$package.json.ts

@@ -3,6 +3,10 @@ import { loadPackageJson, type TransformerProps } from "@batijs/core";
 export default async function getPackageJson(props: TransformerProps): Promise<unknown> {
   const packageJson = await loadPackageJson(props, await import("../package.json").then((x) => x.default));
 
+  const hasPostgres = props.meta.BATI.has("postgres");
+  // better-sqlite3 only for the embedded SQLite engine (not D1, not Postgres).
+  const hasSqliteEngine = !props.meta.BATI.hasD1 && !hasPostgres;
+
   return packageJson
     .setScript("drizzle:generate", {
       value: "drizzle-kit generate",
@@ -19,6 +23,7 @@ export default async function getPackageJson(props: TransformerProps): Promise<u
       precedence: 20,
     })
     .addDependencies(["drizzle-kit", "drizzle-orm", "dotenv"])
-    .addDevDependencies(["@types/better-sqlite3"], !props.meta.BATI.hasD1)
-    .addDependencies(["better-sqlite3"], !props.meta.BATI.hasD1);
+    .addDevDependencies(["@types/better-sqlite3"], hasSqliteEngine)
+    .addDependencies(["better-sqlite3"], hasSqliteEngine)
+    .addDependencies(["postgres"], hasPostgres);
 }

boilerplates/drizzle/files/database/drizzle/db.ts

@@ -1,8 +1,10 @@
 import Database from "better-sqlite3";
 import { drizzle as drizzleSqlite } from "drizzle-orm/better-sqlite3";
 import { drizzle as drizzleD1 } from "drizzle-orm/d1";
+import { drizzle as drizzlePostgres } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
 
-//# !BATI.hasD1
+//# BATI.has("sqlite") && !BATI.hasD1
 export function dbSqlite() {
   const sqlite = new Database(process.env.DATABASE_URL);
   return drizzleSqlite(sqlite);
@@ -12,3 +14,11 @@ export function dbSqlite() {
 export function dbD1(d1: D1Database) {
   return drizzleD1(d1);
 }
+
+//# BATI.has("postgres")
+export function dbPostgres() {
+  if (!process.env.DATABASE_URL) {
+    throw new Error("Missing DATABASE_URL in .env file");
+  }
+  return drizzlePostgres(postgres(process.env.DATABASE_URL));
+}

boilerplates/drizzle/files/database/drizzle/queries/todos.ts

@@ -1,26 +1,29 @@
 /*# BATI include-if-imported #*/
 
-import type { dbD1, dbSqlite } from "../db";
+import type { dbD1, dbPostgres, dbSqlite } from "../db";
 import { todoTable } from "../schema/todos";
 
 export function insertTodo(
   db: BATI.If<{
+    'BATI.has("postgres")': ReturnType<typeof dbPostgres>;
     "!BATI.hasD1": ReturnType<typeof dbSqlite>;
     _: ReturnType<typeof dbD1>;
   }>,
   text: string,
 ) {
-  return db.insert(todoTable).values({ text });
+  return (db as BATI.Any).insert(todoTable).values({ text });
 }
 
 export async function getAllTodos(
   db: BATI.If<
     {
+      'BATI.has("postgres")': ReturnType<typeof dbPostgres>;
       "!BATI.hasD1": ReturnType<typeof dbSqlite>;
       _: ReturnType<typeof dbD1>;
     },
     "union"
   >,
 ) {
-  return db.select().from(todoTable).all();
+  const query = (db as BATI.Any).select().from(todoTable);
+  return BATI.has("postgres") ? query : query.all();
 }

boilerplates/drizzle/files/database/drizzle/schema/todos.ts

@@ -1,11 +1,17 @@
 /*# BATI include-if-imported #*/
+import { pgTable, serial, varchar } from "drizzle-orm/pg-core";
 import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
 
-// Example of defining a schema in Drizzle ORM:
-export const todoTable = sqliteTable("todos", {
-  id: integer("id", { mode: "number" }).primaryKey({ autoIncrement: true }),
-  text: text("text", { length: 50 }).notNull(),
-});
+// Example of defining a schema in Drizzle ORM.
+export const todoTable = BATI.has("postgres")
+  ? pgTable("todos", {
+      id: serial("id").primaryKey(),
+      text: varchar("text", { length: 50 }).notNull(),
+    })
+  : sqliteTable("todos", {
+      id: integer("id", { mode: "number" }).primaryKey({ autoIncrement: true }),
+      text: text("text", { length: 50 }).notNull(),
+    });
 
 // You can then infer the types for selecting and inserting
 export type TodoItem = typeof todoTable.$inferSelect;

boilerplates/drizzle/files/drizzle.config.ts

@@ -8,7 +8,7 @@ if (!BATI.hasD1) {
 }
 
 export default defineConfig({
-  dialect: "sqlite",
+  dialect: BATI.has("postgres") ? "postgresql" : "sqlite",
   schema: "./database/drizzle/schema/*",
   out: "./database/migrations",
   //# !BATI.hasD1

boilerplates/drizzle/package.json

@@ -19,7 +19,8 @@
     "better-sqlite3": "^12.10.0",
     "dotenv": "^17.4.2",
     "drizzle-kit": "^0.31.10",
-    "drizzle-orm": "^0.45.2"
+    "drizzle-orm": "^0.45.2",
+    "postgres": "^3.4.7"
   },
   "files": [
     "dist/"

boilerplates/express/files/+server.ts

@@ -16,7 +16,7 @@ function getHandler() {
   const app = express();
 
   vike(app, [
-    //# BATI.hasDatabase
+    //# BATI.hasDbDemo
     // Make database available in Context as `context.db`
     dbMiddleware,
     //# BATI.has("authjs") || BATI.has("auth0")

boilerplates/fastify/files/+server.ts

@@ -23,7 +23,7 @@ async function getHandler() {
   await app.register(rawBody);
 
   await vike(app, [
-    //# BATI.hasDatabase
+    //# BATI.hasDbDemo
     // Make database available in Context as `context.db`
     dbMiddleware,
     //# BATI.has("authjs") || BATI.has("auth0")

boilerplates/h3/files/+server.ts

@@ -16,7 +16,7 @@ function getHandler() {
   const app = createApp();
 
   vike(app, [
-    //# BATI.hasDatabase
+    //# BATI.hasDbDemo
     // Make database available in Context as `context.db`
     dbMiddleware,
     //# BATI.has("authjs") || BATI.has("auth0")

boilerplates/hono/files/server/hono.ts

@@ -11,7 +11,7 @@ function getApp() {
   const app = new Hono();
 
   vike(app, [
-    //# BATI.hasDatabase
+    //# BATI.hasDbDemo
     // Make database available in Context as `context.db`
     dbMiddleware,
     //# BATI.has("authjs") || BATI.has("auth0")

boilerplates/kysely/files/$package.json.ts

@@ -1,4 +1,4 @@
-import { loadPackageJson, type TransformerProps } from "@batijs/core";
+import { loadPackageJson, packageManager, type TransformerProps } from "@batijs/core";
 
 export default async function getPackageJson(props: TransformerProps): Promise<unknown> {
   const packageJson = await loadPackageJson(props, await import("../package.json").then((x) => x.default));
@@ -8,12 +8,19 @@ export default async function getPackageJson(props: TransformerProps): Promise<u
     return packageJson.addDependencies(["kysely", "kysely-d1"]);
   }
 
+  const hasPostgres = props.meta.BATI.has("postgres");
+  // Bun runs TypeScript directly; Node needs tsx. SQLite stays on tsx even under
+  // Bun because the migration loads better-sqlite3, which has no Bun build.
+  const bunDirect = packageManager().name === "bun" && hasPostgres;
+
   return packageJson
     .setScript("kysely:migrate", {
-      value: "tsx ./database/kysely/migrate.ts",
+      value: `${bunDirect ? "bun" : "tsx"} ./database/kysely/migrate.ts`,
       precedence: 20,
     })
-    .addDevDependencies(["@types/better-sqlite3"])
-    .addDevDependencies(["tsx"], ["kysely:migrate"])
-    .addDependencies(["better-sqlite3", "dotenv", "kysely"]);
+    .addDevDependencies(["@types/better-sqlite3"], !hasPostgres)
+    .addDevDependencies(["tsx"], ["kysely:migrate"], !bunDirect)
+    .addDependencies(["dotenv", "kysely"])
+    .addDependencies(["better-sqlite3"], !hasPostgres)
+    .addDependencies(["postgres", "kysely-postgres-js"], hasPostgres);
 }

boilerplates/kysely/files/database/kysely/db.ts

@@ -5,9 +5,11 @@ import "dotenv/config";
 import SQLite from "better-sqlite3";
 import { Kysely, SqliteDialect } from "kysely";
 import { D1Dialect } from "kysely-d1";
+import { PostgresJSDialect } from "kysely-postgres-js";
+import postgres from "postgres";
 import type { Database } from "./types";
 
-//# !BATI.hasD1
+//# BATI.has("sqlite") && !BATI.hasD1
 export function dbKysely() {
   const dialect = new SqliteDialect({
     database: new SQLite(process.env.DATABASE_URL),
@@ -23,3 +25,13 @@ export function dbKyselyD1(d1: D1Database) {
     dialect: new D1Dialect({ database: d1 }),
   });
 }
+
+//# BATI.has("postgres")
+export function dbKyselyPostgres() {
+  if (!process.env.DATABASE_URL) {
+    throw new Error("Missing DATABASE_URL in .env file");
+  }
+  return new Kysely<Database>({
+    dialect: new PostgresJSDialect({ postgres: postgres(process.env.DATABASE_URL) }),
+  });
+}

boilerplates/kysely/files/database/kysely/migrate.ts

@@ -5,13 +5,13 @@ import * as path from "node:path";
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { FileMigrationProvider, Migrator } from "kysely/migration";
-import { dbKysely } from "./db";
+import { dbKysely, dbKyselyPostgres } from "./db";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 async function migrateToLatest() {
-  const db = dbKysely();
+  const db = BATI.has("postgres") ? dbKyselyPostgres() : dbKysely();
   const migrator = new Migrator({
     db,
     provider: new FileMigrationProvider({

boilerplates/kysely/files/database/kysely/migrations/001_create_todos_table.ts

@@ -3,11 +3,10 @@ import type { Kysely } from "kysely";
 import type { Database } from "../types";
 
 export async function up(db: Kysely<Database>): Promise<void> {
-  await db.schema
-    .createTable("todos")
-    .addColumn("id", "integer", (col) => col.primaryKey().autoIncrement())
-    .addColumn("text", "text", (col) => col.notNull())
-    .execute();
+  const withId = BATI.has("postgres")
+    ? db.schema.createTable("todos").addColumn("id", "serial", (col) => col.primaryKey())
+    : db.schema.createTable("todos").addColumn("id", "integer", (col) => col.primaryKey().autoIncrement());
+  await withId.addColumn("text", "text", (col) => col.notNull()).execute();
 }
 
 export async function down(db: Kysely<Database>): Promise<void> {

boilerplates/kysely/files/database/kysely/queries/todos.ts

@@ -1,7 +1,8 @@
-import type { dbKysely, dbKyselyD1 } from "../db";
+import type { dbKysely, dbKyselyD1, dbKyselyPostgres } from "../db";
 
 export async function insertTodo(
   db: BATI.If<{
+    'BATI.has("postgres")': ReturnType<typeof dbKyselyPostgres>;
     "!BATI.hasD1": ReturnType<typeof dbKysely>;
     "BATI.hasD1": ReturnType<typeof dbKyselyD1>;
   }>,
@@ -12,6 +13,7 @@ export async function insertTodo(
 
 export async function getAllTodos(
   db: BATI.If<{
+    'BATI.has("postgres")': ReturnType<typeof dbKyselyPostgres>;
     "!BATI.hasD1": ReturnType<typeof dbKysely>;
     "BATI.hasD1": ReturnType<typeof dbKyselyD1>;
   }>,