add mongoose orm to the stack builder (#191)

apps/cli/src/constants.ts

@@ -40,6 +40,8 @@ export const dependencyVersionMap = {
 	"@prisma/client": "^6.7.0",
 	prisma: "^6.7.0",
 
+	mongoose: "^8.14.0",
+
 	"vite-plugin-pwa": "^0.21.2",
 	"@vite-pwa/assets-generator": "^0.2.6",
 

apps/cli/src/helpers/db-setup.ts

@@ -62,6 +62,12 @@ export async function setupDatabase(config: ProjectConfig): Promise<void> {
 					projectDir: serverDir,
 				});
 			}
+		} else if (orm === "mongoose") {
+			await addPackageDependency({
+				dependencies: ["mongoose"],
+				devDependencies: [],
+				projectDir: serverDir,
+			});
 		}
 
 		if (database === "sqlite" && dbSetup === "turso") {

apps/cli/src/helpers/template-manager.ts

@@ -367,6 +367,11 @@ export async function setupAuthTemplate(
 					PKG_ROOT,
 					`templates/auth/server/db/prisma/${db}`,
 				);
+			} else if (orm === "mongoose") {
+				authDbSrc = path.join(
+					PKG_ROOT,
+					`templates/auth/server/db/mongoose/${db}`,
+				)
 			}
 			if (authDbSrc && (await fs.pathExists(authDbSrc))) {
 				await processAndCopyFiles("**/*", authDbSrc, serverAppDir, context);

apps/cli/src/index.ts

@@ -60,7 +60,7 @@ async function main() {
 			.option("orm", {
 				type: "string",
 				describe: "ORM type",
-				choices: ["drizzle", "prisma", "none"],
+				choices: ["drizzle", "prisma", "mongoose", "none"],
 			})
 			.option("auth", {
 				type: "boolean",
@@ -446,78 +446,82 @@ function processAndValidateFlags(
 			config.dbSetup = "none";
 		}
 
-		if (effectiveDatabase === "mongodb" && effectiveOrm === "drizzle") {
+	if (effectiveDatabase === "mongodb" && effectiveOrm === "drizzle") {
+		consola.fatal(
+			"Drizzle ORM is not compatible with MongoDB. Please use --orm prisma or --orm mongoose.",
+		);
+		process.exit(1);
+	}
+
+	if (
+		effectiveOrm === "mongoose" &&
+		effectiveDatabase &&
+		effectiveDatabase !== "mongodb"
+	) {
+		consola.fatal(
+			`Mongoose ORM requires MongoDB. Cannot use --orm mongoose with --database ${effectiveDatabase}.`,
+		);
+		process.exit(1);
+	}
+
+	if (config.dbSetup && config.dbSetup !== "none") {
+		const dbSetup = config.dbSetup;
+
+		if (!effectiveDatabase || effectiveDatabase === "none") {
 			consola.fatal(
-				"MongoDB is only available with Prisma. Cannot use --database mongodb with --orm drizzle",
+				`Database setup '--db-setup ${dbSetup}' requires a database. Cannot use when database is 'none'.`,
 			);
 			process.exit(1);
 		}
 
-		if (config.dbSetup && config.dbSetup !== "none") {
-			const dbSetup = config.dbSetup;
-			if (dbSetup === "turso") {
-				if (effectiveDatabase && effectiveDatabase !== "sqlite") {
-					consola.fatal(
-						`Turso setup requires SQLite. Cannot use --db-setup turso with --database ${effectiveDatabase}`,
-					);
-					process.exit(1);
-				}
-				if (effectiveOrm === "prisma") {
-					consola.fatal(
-						"Turso setup is not compatible with Prisma. Cannot use --db-setup turso with --orm prisma",
-					);
-					process.exit(1);
-				}
-				config.database = "sqlite";
-				config.orm = "drizzle";
-			} else if (dbSetup === "prisma-postgres") {
-				if (effectiveDatabase && effectiveDatabase !== "postgres") {
-					consola.fatal(
-						`Prisma PostgreSQL setup requires PostgreSQL. Cannot use --db-setup prisma-postgres with --database ${effectiveDatabase}.`,
-					);
-					process.exit(1);
-				}
-				if (
-					effectiveOrm &&
-					effectiveOrm !== "prisma" &&
-					effectiveOrm !== "none"
-				) {
-					consola.fatal(
-						`Prisma PostgreSQL setup requires Prisma ORM. Cannot use --db-setup prisma-postgres with --orm ${effectiveOrm}.`,
-					);
-					process.exit(1);
-				}
-				config.database = "postgres";
-				config.orm = "prisma";
-			} else if (dbSetup === "mongodb-atlas") {
-				if (effectiveDatabase && effectiveDatabase !== "mongodb") {
-					consola.fatal(
-						`MongoDB Atlas setup requires MongoDB. Cannot use --db-setup mongodb-atlas with --database ${effectiveDatabase}.`,
-					);
-					process.exit(1);
-				}
-				if (
-					effectiveOrm &&
-					effectiveOrm !== "prisma" &&
-					effectiveOrm !== "none"
-				) {
-					consola.fatal(
-						`MongoDB Atlas setup requires Prisma ORM. Cannot use --db-setup mongodb-atlas with --orm ${effectiveOrm}.`,
-					);
-					process.exit(1);
-				}
-				config.database = "mongodb";
-				config.orm = "prisma";
-			} else if (dbSetup === "neon") {
-				if (effectiveDatabase && effectiveDatabase !== "postgres") {
-					consola.fatal(
-						`Neon PostgreSQL setup requires PostgreSQL. Cannot use --db-setup neon with --database ${effectiveDatabase}.`,
-					);
-					process.exit(1);
-				}
-				config.database = "postgres";
+		if (dbSetup === "turso") {
+			if (effectiveDatabase && effectiveDatabase !== "sqlite") {
+				consola.fatal(
+					`Turso setup requires SQLite. Cannot use --db-setup turso with --database ${effectiveDatabase}`,
+				);
+				process.exit(1);
+			}
+			if (effectiveOrm !== "drizzle") {
+				consola.fatal(
+					`Turso setup requires Drizzle ORM. Cannot use --db-setup turso with --orm ${effectiveOrm ?? "none"}.`,
+				);
+				process.exit(1);
+			}
+		} else if (dbSetup === "prisma-postgres") {
+			if (effectiveDatabase !== "postgres") {
+				consola.fatal(
+					`Prisma PostgreSQL setup requires PostgreSQL. Cannot use --db-setup prisma-postgres with --database ${effectiveDatabase}.`,
+				);
+				process.exit(1);
+			}
+			if (effectiveOrm !== "prisma") {
+				consola.fatal(
+					`Prisma PostgreSQL setup requires Prisma ORM. Cannot use --db-setup prisma-postgres with --orm ${effectiveOrm}.`,
+				);
+				process.exit(1);
+			}
+		} else if (dbSetup === "mongodb-atlas") {
+			if (effectiveDatabase !== "mongodb") {
+				consola.fatal(
+					`MongoDB Atlas setup requires MongoDB. Cannot use --db-setup mongodb-atlas with --database ${effectiveDatabase}.`,
+				);
+				process.exit(1);
+			}
+			if (effectiveOrm !== "prisma" && effectiveOrm !== "mongoose") {
+				consola.fatal(
+					`MongoDB Atlas setup requires Prisma or Mongoose ORM. Cannot use --db-setup mongodb-atlas with --orm ${effectiveOrm}.`,
+				);
+				process.exit(1);
+			}
+		} else if (dbSetup === "neon") {
+			if (effectiveDatabase !== "postgres") {
+				consola.fatal(
+					`Neon PostgreSQL setup requires PostgreSQL. Cannot use --db-setup neon with --database ${effectiveDatabase}.`,
+				);
+				process.exit(1);
 			}
 		}
+	}
 
 		const includesNuxt = effectiveFrontend?.includes("nuxt");
 		const includesSvelte = effectiveFrontend?.includes("svelte");
@@ -576,13 +580,13 @@ function processAndValidateFlags(
 				process.exit(1);
 			}
 
-			if (config.addons.includes("husky") && !config.addons.includes("biome")) {
-				consola.warn(
-					"Husky addon is recommended to be used with Biome for lint-staged configuration.",
-				);
-			}
-			config.addons = [...new Set(config.addons)];
+		if (config.addons.includes("husky") && !config.addons.includes("biome")) {
+			consola.warn(
+				"Husky addon is recommended to be used with Biome for lint-staged configuration.",
+			);
 		}
+		config.addons = [...new Set(config.addons)];
+	}
 
 		const onlyNativeFrontend =
 			effectiveFrontend &&

apps/cli/src/prompts/orm.ts

@@ -3,6 +3,24 @@ import pc from "picocolors";
 import { DEFAULT_CONFIG } from "../constants";
 import type { ProjectBackend, ProjectDatabase, ProjectOrm } from "../types";
 
+const ormOptions = {
+	prisma: {
+		value: "prisma" as const,
+		label: "Prisma",
+		hint: "Powerful, feature-rich ORM",
+	},
+	mongoose: {
+		value: "mongoose" as const,
+		label: "Mongoose",
+		hint: "Elegant object modeling tool",
+	},
+	drizzle: {
+		value: "drizzle" as const,
+		label: "Drizzle",
+		hint: "Lightweight and performant TypeScript ORM",
+	},
+};
+
 export async function getORMChoice(
 	orm: ProjectOrm | undefined,
 	hasDatabase: boolean,
@@ -16,26 +34,16 @@ export async function getORMChoice(
 	if (!hasDatabase) return "none";
 	if (orm !== undefined) return orm;
 
-	if (database === "mongodb") {
-		log.info("Only Prisma is supported with MongoDB.");
-		return "prisma";
-	}
+	const options = [
+		...(database === "mongodb"
+			? [ormOptions.prisma, ormOptions.mongoose]
+			: [ormOptions.drizzle, ormOptions.prisma]),
+	];
 
 	const response = await select<ProjectOrm>({
 		message: "Select ORM",
-		options: [
-			{
-				value: "drizzle",
-				label: "Drizzle",
-				hint: "lightweight and performant TypeScript ORM",
-			},
-			{
-				value: "prisma",
-				label: "Prisma",
-				hint: "Powerful, feature-rich ORM",
-			},
-		],
-		initialValue: DEFAULT_CONFIG.orm,
+		options,
+		initialValue: database === "mongodb" ? "prisma" : DEFAULT_CONFIG.orm,
 	});
 
 	if (isCancel(response)) {

apps/cli/src/types.ts

@@ -4,7 +4,7 @@ export type ProjectDatabase =
 	| "mongodb"
 	| "mysql"
 	| "none";
-export type ProjectOrm = "drizzle" | "prisma" | "none";
+export type ProjectOrm = "drizzle" | "prisma" | "mongoose" | "none";
 export type ProjectPackageManager = "npm" | "pnpm" | "bun";
 export type ProjectAddons =
 	| "pwa"

apps/cli/templates/auth/server/base/src/lib/auth.ts.hbs

@@ -58,6 +58,31 @@ export const auth = betterAuth({
 });
 {{/if}}
 
+{{#if (eq orm "mongoose")}}
+import { betterAuth } from "better-auth";
+import { mongodbAdapter } from "better-auth/adapters/mongodb";
+{{#if (includes frontend "native")}}
+import { expo } from "@better-auth/expo";
+{{/if}}
+import { client } from "../db";
+
+export const auth = betterAuth({
+    database: mongodbAdapter(client.db()),
+    trustedOrigins: [
+        process.env.CORS_ORIGIN || "",{{#if (includes frontend "native")}}
+        "my-better-t-app://",{{/if}}
+    ],
+    emailAndPassword: {
+        enabled: true,
+    }
+
+    {{~#if (includes frontend "native")}}
+        ,
+        plugins: [expo()]
+    {{/if~}}
+});
+{{/if}}
+
 {{#if (eq orm "none")}}
 import { betterAuth } from "better-auth";
 {{#if (includes frontend "native")}}

apps/cli/templates/auth/server/db/mongoose/mongodb/src/db/models/auth.model.ts

@@ -0,0 +1,68 @@
+import mongoose from 'mongoose';
+
+const { Schema, model } = mongoose;
+
+const userSchema = new Schema(
+    {
+        _id: { type: String },
+        name: { type: String, required: true },
+        email: { type: String, required: true, unique: true },
+        emailVerified: { type: Boolean, required: true },
+        image: { type: String },
+        createdAt: { type: Date, required: true },
+        updatedAt: { type: Date, required: true },
+    },
+    { collection: 'user' }
+);
+
+const sessionSchema = new Schema(
+    {
+        _id: { type: String },
+        expiresAt: { type: Date, required: true },
+        token: { type: String, required: true, unique: true },
+        createdAt: { type: Date, required: true },
+        updatedAt: { type: Date, required: true },
+        ipAddress: { type: String },
+        userAgent: { type: String },
+        userId: { type: String, ref: 'User', required: true },
+    },
+    { collection: 'session' }
+);
+
+const accountSchema = new Schema(
+    {
+        _id: { type: String },
+        accountId: { type: String, required: true },
+        providerId: { type: String, required: true },
+        userId: { type: String, ref: 'User', required: true },
+        accessToken: { type: String },
+        refreshToken: { type: String },
+        idToken: { type: String },
+        accessTokenExpiresAt: { type: Date },
+        refreshTokenExpiresAt: { type: Date },
+        scope: { type: String },
+        password: { type: String },
+        createdAt: { type: Date, required: true },
+        updatedAt: { type: Date, required: true },
+    },
+    { collection: 'account' }
+);
+
+const verificationSchema = new Schema(
+    {
+        _id: { type: String },
+        identifier: { type: String, required: true },
+        value: { type: String, required: true },
+        expiresAt: { type: Date, required: true },
+        createdAt: { type: Date },
+        updatedAt: { type: Date },
+    },
+    { collection: 'verification' }
+);
+
+const User = model('User', userSchema);
+const Session = model('Session', sessionSchema);
+const Account = model('Account', accountSchema);
+const Verification = model('Verification', verificationSchema);
+
+export { User, Session, Account, Verification };

apps/cli/templates/db/mongoose/mongodb/src/db/index.ts

@@ -0,0 +1,6 @@
+import mongoose from 'mongoose';
+
+await mongoose.connect(process.env.DATABASE_URL || "");
+const client = mongoose.connection.getClient();
+
+export { client };

apps/cli/templates/examples/todo/server/mongoose/base/src/routers/todo.ts.hbs

@@ -0,0 +1,66 @@
+{{#if (eq api "orpc")}}
+import { z } from "zod";
+import { publicProcedure } from "../lib/orpc";
+import { Todo } from "../db/models/todo.model";
+
+export const todoRouter = {
+    getAll: publicProcedure.handler(async () => {
+        return await Todo.find().lean();
+    }),
+
+    create: publicProcedure
+        .input(z.object({ text: z.string().min(1) }))
+        .handler(async ({ input }) => {
+            const newTodo = await Todo.create({ text: input.text });
+            return newTodo.toObject();
+    }),
+
+    toggle: publicProcedure
+        .input(z.object({ id: z.string(), completed: z.boolean() }))
+        .handler(async ({ input }) => {
+            await Todo.updateOne({ id: input.id }, { completed: input.completed });
+            return { success: true };
+    }),
+
+    delete: publicProcedure
+        .input(z.object({ id: z.string() }))
+        .handler(async ({ input }) => {
+            await Todo.deleteOne({ id: input.id });
+            return { success: true };
+    }),
+};
+
+{{/if}}
+
+{{#if (eq api "trpc")}}
+import { z } from "zod";
+import { router, publicProcedure } from "../lib/trpc";
+import { Todo } from "../db/models/todo.model";
+
+export const todoRouter = router({
+    getAll: publicProcedure.query(async () => {
+        return await Todo.find().lean();
+    }),
+
+    create: publicProcedure
+        .input(z.object({ text: z.string().min(1) }))
+        .mutation(async ({ input }) => {
+            const newTodo = await Todo.create({ text: input.text });
+        return newTodo.toObject();
+    }),
+
+    toggle: publicProcedure
+        .input(z.object({ id: z.string(), completed: z.boolean() }))
+        .mutation(async ({ input }) => {
+            await Todo.updateOne({ id: input.id }, { completed: input.completed });
+            return { success: true };
+    }),
+
+    delete: publicProcedure
+        .input(z.object({ id: z.string() }))
+        .mutation(async ({ input }) => {
+            await Todo.deleteOne({ id: input.id });
+            return { success: true };
+    }),
+});
+{{/if}}

apps/cli/templates/examples/todo/server/mongoose/mongodb/src/db/models/todo.model.ts

@@ -0,0 +1,24 @@
+import mongoose from 'mongoose';
+
+const { Schema, model } = mongoose;
+
+const todoSchema = new Schema({
+  id: {
+    type: mongoose.Schema.Types.ObjectId,
+    auto: true,
+  },
+  text: {
+    type: String,
+    required: true,
+  },
+  completed: {
+    type: Boolean,
+    default: false,
+  },
+}, {
+  collection: 'todo'
+});
+
+const Todo = model('Todo', todoSchema);
+
+export { Todo };