@batijs/cli 0.0.633 → 0.0.634

package/dist/{asset-env-Jk0sS-Q2.js → asset-env-DvKtWq7P.js}

@@ -4,11 +4,14 @@ import { committedValue, isServerVar } from "@batijs/core";
 //#region ../../boilerplates/docker-compose/dist/files/asset-env.mjs
 /**
 * `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).
 */
 function composeEnvEntries(registry) {
-	return registry.filter(isServerVar).map((def) => def.scope === "secret" ? `${def.key}=\${${def.key}}` : `${def.key}=\${${def.key}:-${committedValue(def, "compose")}}`);
+	return registry.filter(isServerVar).map((def) => def.scope === "secret" ? `${def.key}=\${${def.key}}` : `${def.key}=${committedValue(def, "compose")}`);
 }
 /**
 * Dockerfile `ENV` defaults grouped by `group` (first-seen order), one

package/dist/{asset-package.json-BgXWfTnb.js → asset-package.json-CBsEdGlU.js}

@@ -20,6 +20,7 @@ var package_default = {
 		"@batijs/d1-sqlite": "workspace:*",
 		"@batijs/drizzle": "workspace:*",
 		"@batijs/kysely": "workspace:*",
+		"@batijs/postgres": "workspace:*",
 		"@batijs/sqlite": "workspace:*",
 		"@types/node": "^20.19.37",
 		"@universal-middleware/core": "^0.4.17",

package/dist/{asset-package.json-CJq8QmFk.js → asset-package.json-CXa26JLJ.js}

@@ -21,6 +21,7 @@ var package_default = {
 		"@batijs/d1-sqlite": "workspace:*",
 		"@batijs/drizzle": "workspace:*",
 		"@batijs/kysely": "workspace:*",
+		"@batijs/postgres": "workspace:*",
 		"@batijs/sqlite": "workspace:*",
 		"@types/node": "^20.19.37",
 		"@universal-middleware/core": "^0.4.17",

package/dist/{asset-package.json-DotEkyyW.js → asset-package.json-CpJdnsXW.js}

@@ -22,7 +22,8 @@ var package_default = {
 		"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/"],
 	exports: {

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

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+//#region ../../boilerplates/postgres/dist/files/asset-package.json.mjs
+var package_default = {
+	name: "@batijs/postgres",
+	"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:*",
+		"@types/node": "^20.19.37",
+		"dotenv": "^17.4.2",
+		"postgres": "^3.4.7",
+		"tsx": "^4.22.3"
+	},
+	files: ["dist/"],
+	exports: {
+		"./database/postgres/db": { "types": "./dist/types/database/postgres/db.d.mts" },
+		"./database/postgres/queries/todos": { "types": "./dist/types/database/postgres/queries/todos.d.mts" },
+		"./database/postgres/schema/all": { "types": "./dist/types/database/postgres/schema/all.d.mts" },
+		"./database/postgres/schema/todos": { "types": "./dist/types/database/postgres/schema/todos.d.mts" }
+	},
+	typesVersions: { "*": {
+		"database/postgres/db": ["./dist/types/database/postgres/db.d.mts"],
+		"database/postgres/queries/todos": ["./dist/types/database/postgres/queries/todos.d.mts"],
+		"database/postgres/schema/all": ["./dist/types/database/postgres/schema/all.d.mts"],
+		"database/postgres/schema/todos": ["./dist/types/database/postgres/schema/todos.d.mts"]
+	} },
+	nx: { "tags": ["type:boilerplate"] }
+};
+//#endregion
+export { package_default as default };

package/dist/{asset-package.json-BfPjhiqX.js → asset-package.json-DcJFVtbo.js}

@@ -24,6 +24,8 @@ var package_default = {
 		"dotenv": "^17.4.2",
 		"kysely": "^0.29.2",
 		"kysely-d1": "^0.4.0",
+		"kysely-postgres-js": "^2.0.0",
+		"postgres": "^3.4.7",
 		"tsx": "^4.22.3",
 		"vite": "^8.0.14"
 	},

package/dist/{asset-package.json-CO-Tvf85.js → asset-package.json-WOGFbHRZ.js}

@@ -20,6 +20,7 @@ var package_default = {
 		"@batijs/d1-sqlite": "workspace:*",
 		"@batijs/drizzle": "workspace:*",
 		"@batijs/kysely": "workspace:*",
+		"@batijs/postgres": "workspace:*",
 		"@batijs/sqlite": "workspace:*",
 		"@trpc/client": "^11.17.0",
 		"@trpc/server": "^11.17.0",

package/dist/{asset-package.json-D5VQND8y.js → asset-package2.json-Cqt3zXsB.js}

@@ -20,6 +20,7 @@ var package_default = {
 		"@batijs/d1-sqlite": "workspace:*",
 		"@batijs/drizzle": "workspace:*",
 		"@batijs/kysely": "workspace:*",
+		"@batijs/postgres": "workspace:*",
 		"@batijs/sqlite": "workspace:*",
 		"@ts-rest/core": "^3.52.1",
 		"@ts-rest/serverless": "^3.52.1",

package/dist/boilerplates/@batijs/d1-sqlite/bati.config.mjs

@@ -8,7 +8,7 @@ function t(t) {
 //#endregion
 //#region bati.config.ts
 var bati_config_default = t({ if(meta) {
-	return meta.BATI.hasD1 && meta.BATI.has("sqlite");
+	return meta.BATI.hasD1 && !meta.BATI.hasOrm;
 } });
 //#endregion
 export { bati_config_default as default };

package/dist/boilerplates/@batijs/docker-compose/files/$Dockerfile.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { n as serverEnvDefaults } from "../../../../asset-env-Jk0sS-Q2.js";
+import { n as serverEnvDefaults } from "../../../../asset-env-DvKtWq7P.js";
 import { dockerPackageManager, dockerfile, packageManager } from "@batijs/core";
 //#region ../../boilerplates/docker-compose/dist/files/$Dockerfile.mjs
 async function getDockerfile(props) {
@@ -20,14 +20,6 @@ async function getDockerfile(props) {
 	const config = dockerPackageManager(pm.name, { frozenLockfile: !meta.BATI_TEST });
 	const startupMigrations = [];
 	const migrationCopies = [];
-	if (meta.BATI.has("sqlite")) {
-		startupMigrations.push(`${run} sqlite:migrate`);
-		migrationCopies.push({
-			sources: ["/app/database/sqlite"],
-			dest: "./database/sqlite",
-			from: "builder"
-		});
-	}
 	if (meta.BATI.has("drizzle")) {
 		startupMigrations.push(`${run} drizzle:migrate`);
 		migrationCopies.push({
@@ -49,6 +41,22 @@ async function getDockerfile(props) {
 			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"
+		});
+	}
 	const startCmd = startupMigrations.length > 0 ? [
 		"sh",
 		"-c",

package/dist/boilerplates/@batijs/docker-compose/files/$docker-compose.yml.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { t as composeEnvEntries } from "../../../../asset-env-Jk0sS-Q2.js";
+import { t as composeEnvEntries } from "../../../../asset-env-DvKtWq7P.js";
 import { setComposeEnvironment } from "@batijs/core";
 //#region ../../boilerplates/docker-compose/dist/files/$docker-compose.yml.mjs
 async function getDockerCompose(props) {

package/dist/boilerplates/@batijs/docker-compose/files/asset-env.mjs

@@ -2,11 +2,14 @@ import { committedValue, isServerVar } from "@batijs/core";
 //#region env.ts
 /**
 * `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).
 */
 function composeEnvEntries(registry) {
-	return registry.filter(isServerVar).map((def) => def.scope === "secret" ? `${def.key}=\${${def.key}}` : `${def.key}=\${${def.key}:-${committedValue(def, "compose")}}`);
+	return registry.filter(isServerVar).map((def) => def.scope === "secret" ? `${def.key}=\${${def.key}}` : `${def.key}=${committedValue(def, "compose")}`);
 }
 /**
 * Dockerfile `ENV` defaults grouped by `group` (first-seen order), one

package/dist/boilerplates/@batijs/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: {}

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

@@ -3,7 +3,10 @@
 import { loadPackageJson } from "@batijs/core";
 //#region ../../boilerplates/drizzle/dist/files/$package.json.mjs
 async function getPackageJson(props) {
-	return (await loadPackageJson(props, await import("../../../../asset-package.json-DotEkyyW.js").then((x) => x.default))).setScript("drizzle:generate", {
+	const packageJson = await loadPackageJson(props, await import("../../../../asset-package.json-CpJdnsXW.js").then((x) => x.default));
+	const hasPostgres = props.meta.BATI.has("postgres");
+	const hasSqliteEngine = !props.meta.BATI.hasD1 && !hasPostgres;
+	return packageJson.setScript("drizzle:generate", {
 		value: "drizzle-kit generate",
 		precedence: 20
 	}).setScript("drizzle:migrate", {
@@ -16,7 +19,7 @@ async function getPackageJson(props) {
 		"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);
 }
 //#endregion
 export { getPackageJson as default };

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

@@ -20,7 +20,8 @@ var package_default = {
 		"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/"],
 	exports: {

package/dist/boilerplates/@batijs/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));
+}

package/dist/boilerplates/@batijs/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();
 }

package/dist/boilerplates/@batijs/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;

package/dist/boilerplates/@batijs/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

package/dist/boilerplates/@batijs/drizzle/types/database/drizzle/db.d.mts

@@ -1,4 +1,5 @@
 import Database from "better-sqlite3";
+import postgres from "postgres";
 
 //#region files/database/drizzle/db.d.ts
 declare function dbSqlite(): import("drizzle-orm/better-sqlite3").BetterSQLite3Database<Record<string, never>> & {
@@ -7,5 +8,8 @@ declare function dbSqlite(): import("drizzle-orm/better-sqlite3").BetterSQLite3D
 declare function dbD1(d1: D1Database): import("drizzle-orm/d1").DrizzleD1Database<Record<string, never>> & {
   $client: D1Database;
 };
+declare function dbPostgres(): import("drizzle-orm/postgres-js").PostgresJsDatabase<Record<string, never>> & {
+  $client: postgres.Sql<{}>;
+};
 //#endregion
-export { dbD1, dbSqlite };
+export { dbD1, dbPostgres, dbSqlite };

package/dist/boilerplates/@batijs/drizzle/types/database/drizzle/queries/todos.d.mts

@@ -1,58 +1,15 @@
-import { dbD1, dbSqlite } from "../db.mjs";
+import { dbD1, dbPostgres, dbSqlite } from "../db.mjs";
 
 //#region files/database/drizzle/queries/todos.d.ts
 declare function insertTodo(db: BATI.If<{
+  'BATI.has("postgres")': ReturnType<typeof dbPostgres>;
   "!BATI.hasD1": ReturnType<typeof dbSqlite>;
   _: ReturnType<typeof dbD1>;
-}>, text: string): import("drizzle-orm/sqlite-core").SQLiteInsertBase<import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
-  name: "todos";
-  schema: undefined;
-  columns: {
-    id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-      name: "id";
-      tableName: "todos";
-      dataType: "number";
-      columnType: "SQLiteInteger";
-      data: number;
-      driverParam: number;
-      notNull: true;
-      hasDefault: true;
-      isPrimaryKey: true;
-      isAutoincrement: false;
-      hasRuntimeDefault: false;
-      enumValues: undefined;
-      baseColumn: never;
-      identity: undefined;
-      generated: undefined;
-    }, {}, {}>;
-    text: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-      name: "text";
-      tableName: "todos";
-      dataType: "string";
-      columnType: "SQLiteText";
-      data: string;
-      driverParam: string;
-      notNull: true;
-      hasDefault: false;
-      isPrimaryKey: false;
-      isAutoincrement: false;
-      hasRuntimeDefault: false;
-      enumValues: [string, ...string[]];
-      baseColumn: never;
-      identity: undefined;
-      generated: undefined;
-    }, {}, {
-      length: 50;
-    }>;
-  };
-  dialect: "sqlite";
-}>, "sync", import("better-sqlite3").RunResult, undefined, false, never>;
+}>, text: string): any;
 declare function getAllTodos(db: BATI.If<{
+  'BATI.has("postgres")': ReturnType<typeof dbPostgres>;
   "!BATI.hasD1": ReturnType<typeof dbSqlite>;
   _: ReturnType<typeof dbD1>;
-}, "union">): Promise<{
-  id: number;
-  text: string;
-}[]>;
+}, "union">): Promise<any>;
 //#endregion
 export { getAllTodos, insertTodo };

package/dist/boilerplates/@batijs/drizzle/types/database/drizzle/schema/todos.d.mts

@@ -1,5 +1,47 @@
 //#region files/database/drizzle/schema/todos.d.ts
-declare const todoTable: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+declare const todoTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+  name: "todos";
+  schema: undefined;
+  columns: {
+    id: import("drizzle-orm/pg-core").PgColumn<{
+      name: "id";
+      tableName: "todos";
+      dataType: "number";
+      columnType: "PgSerial";
+      data: number;
+      driverParam: number;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: true;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    text: import("drizzle-orm/pg-core").PgColumn<{
+      name: "text";
+      tableName: "todos";
+      dataType: "string";
+      columnType: "PgVarchar";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: 50;
+    }>;
+  };
+  dialect: "pg";
+}> | import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
   name: "todos";
   schema: undefined;
   columns: {

package/dist/boilerplates/@batijs/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")

package/dist/boilerplates/@batijs/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")

package/dist/boilerplates/@batijs/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")

package/dist/boilerplates/@batijs/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")

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

@@ -1,18 +1,16 @@
 #!/usr/bin/env node
 
-import { loadPackageJson } from "@batijs/core";
+import { loadPackageJson, packageManager } from "@batijs/core";
 //#region ../../boilerplates/kysely/dist/files/$package.json.mjs
 async function getPackageJson(props) {
-	const packageJson = await loadPackageJson(props, await import("../../../../asset-package.json-BfPjhiqX.js").then((x) => x.default));
+	const packageJson = await loadPackageJson(props, await import("../../../../asset-package.json-DcJFVtbo.js").then((x) => x.default));
 	if (props.meta.BATI.hasD1) return packageJson.addDependencies(["kysely", "kysely-d1"]);
+	const hasPostgres = props.meta.BATI.has("postgres");
+	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);
 }
 //#endregion
 export { getPackageJson as default };

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

@@ -22,6 +22,8 @@ var package_default = {
 		"dotenv": "^17.4.2",
 		"kysely": "^0.29.2",
 		"kysely-d1": "^0.4.0",
+		"kysely-postgres-js": "^2.0.0",
+		"postgres": "^3.4.7",
 		"tsx": "^4.22.3",
 		"vite": "^8.0.14"
 	},

package/dist/boilerplates/@batijs/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) }),
+  });
+}

package/dist/boilerplates/@batijs/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({

package/dist/boilerplates/@batijs/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> {