create-init-mtv-app 1.0.1 → 1.0.3

package/dist/index.mjs

@@ -8,6 +8,7 @@ import inquirer from "inquirer";
 let DB_PROVIDERS = /* @__PURE__ */ function(DB_PROVIDERS$1) {
 	DB_PROVIDERS$1["SUPABASE"] = "Supabase";
 	DB_PROVIDERS$1["DOCKER"] = "Docker";
+	DB_PROVIDERS$1["NONE"] = "None";
 	return DB_PROVIDERS$1;
 }({});
 
@@ -16,6 +17,7 @@ let DB_PROVIDERS = /* @__PURE__ */ function(DB_PROVIDERS$1) {
 let DB_TOOLS = /* @__PURE__ */ function(DB_TOOLS$1) {
 	DB_TOOLS$1["DRIZZLE_ORM"] = "Drizzle ORM";
 	DB_TOOLS$1["SUPABASE_JS_SDK"] = "Supabase JS SDK";
+	DB_TOOLS$1["NONE"] = "None";
 	return DB_TOOLS$1;
 }({});
 
@@ -40,8 +42,91 @@ let UI_LIB = /* @__PURE__ */ function(UI_LIB$1) {
 }({});
 
 //#endregion
-//#region src/installers/dependencies.ts
-async function installDependencies(projectName, dependencies) {
+//#region src/installers/expressjs/expressjs.ts
+async function createExpressApp(projectName) {
+	await fs.ensureDir(projectName);
+	await execa("npm", ["init", "-y"], {
+		cwd: projectName,
+		stdio: "inherit"
+	});
+	const dtosDir = path.join(projectName, "src", "dtos");
+	const handlersDir = path.join(projectName, "src", "handlers");
+	const repositoriesDir = path.join(projectName, "src", "repositories");
+	const servicesDir = path.join(projectName, "src", "services");
+	const routesDir = path.join(projectName, "src", "routes");
+	const middlewareDir = path.join(projectName, "src", "middleware");
+	await Promise.all([
+		fs.ensureDir(dtosDir),
+		fs.ensureDir(handlersDir),
+		fs.ensureDir(repositoriesDir),
+		fs.ensureDir(servicesDir),
+		fs.ensureDir(routesDir),
+		fs.ensureDir(middlewareDir)
+	]);
+	const idParamDtoPath = path.join(dtosDir, "idParam.dto.ts");
+	const paginationDtoPath = path.join(dtosDir, "pagination.dto.ts");
+	const responseDtoPath = path.join(dtosDir, "response.dto.ts");
+	await Promise.all([
+		fs.ensureFile(idParamDtoPath),
+		fs.ensureFile(paginationDtoPath),
+		fs.ensureFile(responseDtoPath)
+	]);
+	await Promise.all([
+		fs.writeFile(idParamDtoPath, idParamDtoTemplate),
+		fs.writeFile(paginationDtoPath, paginationDtoTemplate),
+		fs.writeFile(responseDtoPath, responseDtoTemplate)
+	]);
+	const appFilePath = path.join(projectName, "src", "app.ts");
+	const indexFilePath = path.join(projectName, "index.ts");
+	await Promise.all([fs.ensureFile(appFilePath), fs.ensureFile(indexFilePath)]);
+	await Promise.all([fs.writeFile(appFilePath, appTemplate), fs.writeFile(indexFilePath, indexTemplate)]);
+}
+const appTemplate = `import express from "express";
+import helmet from "helmet";
+import cors from "cors";
+import cookieParser from "cookie-parser";
+import "dotenv/config";
+import swaggerUi from "swagger-ui-express";
+import swaggerDocument from "./swagger.json";
+import morgan from "morgan";
+
+const app = express();
+app.use("/api-docs", swaggerUi.serve, swaggerUi.setup(swaggerDocument)); // mabe AI will help to generate the json file
+app.use(helmet());
+app.use(cors());
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+app.use(cookieParser());
+app.use(morgan("dev"));
+
+app.get("/health", (_req, res) => {
+	res.json({ status: "ok" });
+});
+
+export default app;`;
+const indexTemplate = `import app from "./src/app";
+
+const port = process.env.PORT || 8080;
+app.listen(port, () => {
+	console.log(\`Server is running on port \${ port }\`);
+});`;
+const idParamDtoTemplate = `export type IdParam = {
+	id: string;
+};`;
+const paginationDtoTemplate = `export type Pagination = {
+	page: number;
+	limit: number;
+};`;
+const responseDtoTemplate = `export type Response<T> = {
+	data?: T;
+	message: string;
+	statusCode: number;
+	success: boolean;
+};`;
+
+//#endregion
+//#region src/installers/expressjs/dependencies.ts
+async function installDependencies$1(projectName, dependencies) {
 	await execa("npm", ["install", ...dependencies], {
 		cwd: projectName,
 		stdio: "inherit"
@@ -49,8 +134,8 @@ async function installDependencies(projectName, dependencies) {
 }
 
 //#endregion
-//#region src/installers/devDependencies.ts
-async function installDevDependencies(projectName, devDependencies) {
+//#region src/installers/expressjs/devDependencies.ts
+async function installDevDependencies$1(projectName, devDependencies) {
 	await execa("npm", [
 		"install",
 		"-D",
@@ -62,19 +147,12 @@ async function installDevDependencies(projectName, devDependencies) {
 }
 
 //#endregion
-//#region src/installers/nexjs.ts
-async function createNextApp(projectName) {
+//#region src/installers/nestjs.ts
+async function createNestApp(projectName) {
 	await execa("npx", [
-		"create-next-app@latest",
-		projectName,
-		"--ts",
-		"--tailwind",
-		"--react-compiler",
-		"--biome",
-		"--app",
-		"--src-dir",
-		"--import-alias",
-		"@/*"
+		"@nestjs/cli",
+		"new",
+		projectName
 	], { stdio: "inherit" });
 }
 
@@ -92,27 +170,7 @@ async function createReactApp(projectName) {
 }
 
 //#endregion
-//#region src/installers/expressjs.ts
-async function createNextExpressApp(projectName) {
-	await execa("npx", [
-		"create-next-app@latest",
-		projectName,
-		"--use-npm"
-	], { stdio: "inherit" });
-}
-
-//#endregion
-//#region src/installers/nestjs.ts
-async function createNestApp(projectName) {
-	await execa("npx", [
-		"@nestjs/cli",
-		"new",
-		projectName
-	], { stdio: "inherit" });
-}
-
-//#endregion
-//#region src/setups/husky_lint-staged.ts
+//#region src/configs/husky_lint-staged.ts
 async function setupHuskyLintStaged(projectName) {
 	const preCommitPath = path.join(projectName, ".husky", "pre-commit");
 	const prePushPath = path.join(projectName, ".husky", "pre-push");
@@ -121,24 +179,27 @@ async function setupHuskyLintStaged(projectName) {
 	const packageJsonPath = path.join(projectName, "package.json");
 	const packageJson = await fs.readJson(packageJsonPath);
 	packageJson["lint-staged"] = { "*.{ts,tsx,js,jsx,json,css}": ["npm run format", "npm run lint"] };
+	packageJson.scripts["prepare"] = "husky";
+	packageJson.scripts["lint"] = "biome check";
+	packageJson.scripts["format"] = "biome format --write";
 	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
 }
 
 //#endregion
-//#region src/setups/next_supabase_client.ts
-async function setupNextSupabaseClient(projectDir) {
+//#region src/configs/nextjs/supabase_client.ts
+async function setupSupabaseClient(projectDir) {
 	const supabaseDir = path.join(projectDir, "src", "lib", "supabase");
 	await fs.ensureDir(supabaseDir);
 	const supabaseClientPath = path.join(supabaseDir, "client.ts");
 	const supabaseServerPath = path.join(supabaseDir, "server.ts");
 	const supabaseAdminPath = path.join(supabaseDir, "admin.ts");
 	await Promise.all([
-		fs.writeFile(supabaseClientPath, supabaseClientTemplate),
+		fs.writeFile(supabaseClientPath, supabaseClientTemplate$1),
 		fs.writeFile(supabaseServerPath, supabaseServerTemplate),
-		fs.writeFile(supabaseAdminPath, supabaseAdminTemplate)
+		fs.writeFile(supabaseAdminPath, supabaseAdminTemplate$1)
 	]);
 }
-const supabaseClientTemplate = `import { createBrowserClient } from "@supabase/ssr";
+const supabaseClientTemplate$1 = `import { createBrowserClient } from "@supabase/ssr";
 import { sharedEnv } from "../../../env.shared";
 
 export function createClient() {
@@ -177,7 +238,7 @@ export async function createClient() {
   );
 }
 `.trimStart();
-const supabaseAdminTemplate = `import "server-only";
+const supabaseAdminTemplate$1 = `import "server-only";
 import { createClient } from "@supabase/supabase-js";
 import { serverEnv } from "@/backend/env.server";
 import { sharedEnv } from "../../../env.shared";
@@ -196,8 +257,8 @@ export function createAdminClient() {
 `.trimStart();
 
 //#endregion
-//#region src/setups/next_env.ts
-async function setupNextEnv(projectName, isSupabase = false) {
+//#region src/configs/nextjs/env.ts
+async function setupEnv(projectName, isSupabase = false) {
 	const sharedEnvPath = path.join(projectName, "env.shared.ts");
 	const backendDir = path.join(projectName, "src", "backend");
 	const serverEnvPath = path.join(backendDir, "env.server.ts");
@@ -252,7 +313,7 @@ export const sharedEnv = parsed.data;
 `.trimStart();
 
 //#endregion
-//#region src/setups/drizzle.ts
+//#region src/configs/nextjs/drizzle.ts
 async function setupDrizzle(projectName) {
 	const schemasDir = path.join(projectName, "src", "backend", "db", "schemas");
 	const migrationsDir = path.join(projectName, "src", "backend", "db", "migrations");
@@ -262,7 +323,7 @@ async function setupDrizzle(projectName) {
 		fs.ensureDir(migrationsDir),
 		fs.ensureFile(drizzleConfigPath)
 	]);
-	await fs.writeFile(drizzleConfigPath, drizzleConfigTemplate);
+	await fs.writeFile(drizzleConfigPath, drizzleConfigTemplate$1);
 	const packageJsonPath = path.join(projectName, "package.json");
 	const packageJson = await fs.readJson(packageJsonPath);
 	packageJson.scripts["db:generate"] = "npx drizzle-kit generate --config=./src/backend/db/drizzle.config.ts";
@@ -272,7 +333,7 @@ async function setupDrizzle(projectName) {
 	packageJson.scripts["db:check"] = "npx drizzle-kit check --config=./src/backend/db/drizzle.config.ts";
 	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
 }
-const drizzleConfigTemplate = `import "server-only";
+const drizzleConfigTemplate$1 = `import "server-only";
 import { defineConfig } from "drizzle-kit";
 import { serverEnv } from "../env.server";
 
@@ -283,15 +344,19 @@ export default defineConfig({
   dbCredentials: {
     url: serverEnv.DATABASE_URL,
   },
+  verbose: true,
+  strict: true
 });
 `.trimStart();
 
 //#endregion
-//#region src/setups/shadcn.ts
+//#region src/configs/nextjs/shadcn.ts
 async function setupShadcn(projectName) {
 	await execa("npx", [
 		"shadcn@latest",
 		"init",
+		"-b",
+		"neutral",
 		"dialog",
 		"avatar",
 		"button-group",
@@ -319,7 +384,7 @@ async function setupShadcn(projectName) {
 }
 
 //#endregion
-//#region src/setups/biome.ts
+//#region src/configs/nextjs/biome.ts
 async function setupBiome(projectName, isShadcn) {
 	const biomePath = path.join(projectName, "biome.json");
 	const biomeConfig = await fs.readJson(biomePath);
@@ -330,9 +395,9 @@ async function setupBiome(projectName, isShadcn) {
 }
 
 //#endregion
-//#region src/setups/next_supabase_local.ts
-async function setupNextSupabaseLocal(projectDir) {
-	execa("npx", ["supabase", "init"], {
+//#region src/configs/nextjs/supabase_local.ts
+async function setupSupabaseLocal(projectDir) {
+	await execa("npx", ["supabase", "init"], {
 		cwd: projectDir,
 		stdio: "inherit"
 	});
@@ -345,21 +410,22 @@ async function setupNextSupabaseLocal(projectDir) {
 }
 
 //#endregion
-//#region src/setups/jest.ts
+//#region src/configs/nextjs/jest.ts
 async function setupJest(projectName) {
 	const jestConfigPath = path.join(projectName, "jest.config.ts");
 	await fs.ensureFile(jestConfigPath);
-	await fs.writeFile(jestConfigPath, jestConfigTemplate);
+	await fs.writeFile(jestConfigPath, jestConfigTemplate$1);
 	const packageJsonPath = path.join(projectName, "package.json");
 	const packageJson = await fs.readJson(packageJsonPath);
 	packageJson.scripts["test:unit"] = "jest --testPathPatterns=unit";
 	packageJson.scripts["test:integration"] = "jest --testPathPatterns=integration";
+	packageJson.scripts["test"] = "jest";
 	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
 	const testUnitDir = path.join(projectName, "src", "backend", "test", "unit");
 	const testIntegrationDir = path.join(projectName, "src", "backend", "test", "integration");
 	await Promise.all([fs.ensureDir(testUnitDir), fs.ensureDir(testIntegrationDir)]);
 }
-const jestConfigTemplate = `import type { Config } from "jest";
+const jestConfigTemplate$1 = `import type { Config } from "jest";
 
 const config: Config = {
   clearMocks: true,
@@ -382,55 +448,377 @@ const config: Config = {
 export default config;
 `.trimStart();
 
+//#endregion
+//#region src/configs/docker_postgres.ts
+async function setupDockerPostgres(projectName) {
+	const dockerComposePath = path.join(projectName, "docker-compose.yml");
+	await fs.ensureFile(dockerComposePath);
+	await fs.writeFile(dockerComposePath, dockerComposeTemplate);
+}
+const dockerComposeTemplate = `
+version: '3'
+services:
+  postgres:
+    image: postgres:17
+    ports:
+    - 5432:5432
+    environment:
+    - POSTGRES_USER=postgres
+    - POSTGRES_PASSWORD=postgres
+    - POSTGRES_DB=postgres
+    volumes:
+    - postgres_data:/var/lib/postgresql/data
+volumes:
+  postgres_data:
+`;
+
+//#endregion
+//#region src/configs/expressjs/env.ts
+async function configEnv(projectName, isSupabase = false) {
+	const envPath = path.join(projectName, "src", "env.ts");
+	await fs.ensureFile(envPath);
+	await fs.writeFile(envPath, envTemplate(isSupabase));
+}
+const envTemplate = (isSupabase) => `import { z } from "zod";
+
+const envSchema = z.object({
+	NODE_ENV: z
+		.enum(["development", "production", "test"])
+		.default("development"),
+	DATABASE_URL: z.string().min(1, "Database URL is required"),
+	${isSupabase ? "SUPABASE_SERVICE_ROLE_KEY: z.string().min(1, \"Supabase service role key is required\")," : ""}
+	${isSupabase ? "SUPABASE_URL: z.string().min(1, \"Supabase URL is required\")," : ""}
+	${isSupabase ? "SUPABASE_ANON_KEY: z.string().min(1, \"Supabase anon key is required\")," : ""}
+});
+
+const parsed = envSchema.safeParse(process.env);
+
+if (!parsed.success) {
+	console.error("❌ Invalid environment variables:");
+	console.error(JSON.stringify(parsed.error.format(), null, 2));
+	throw new Error("Invalid environment variables");
+}
+
+export const env = parsed.data;
+`.trimStart();
+
+//#endregion
+//#region src/configs/expressjs/supabase_client.ts
+async function configSupabaseClient(projectName) {
+	const supabaseDir = path.join(projectName, "src", "db", "supabase");
+	await fs.ensureDir(supabaseDir);
+	const supabaseClientPath = path.join(supabaseDir, "client.ts");
+	const supabaseAdminPath = path.join(supabaseDir, "admin.ts");
+	await Promise.all([fs.ensureFile(supabaseClientPath), fs.ensureFile(supabaseAdminPath)]);
+	await Promise.all([fs.writeFile(supabaseClientPath, supabaseClientTemplate), fs.writeFile(supabaseAdminPath, supabaseAdminTemplate)]);
+}
+const supabaseClientTemplate = `import { createClient } from "@supabase/supabase-js";
+import { env } from "../../env";
+
+const supabase = createClient(env.SUPABASE_URL, env.SUPABASE_ANON_KEY);
+export default supabase;
+`;
+const supabaseAdminTemplate = `import { createClient } from "@supabase/supabase-js";
+import { env } from "../../env";
+
+const supabaseAdmin = createClient(
+	env.SUPABASE_URL,
+	env.SUPABASE_SERVICE_ROLE_KEY,
+	{
+		auth: {
+			autoRefreshToken: false,
+			persistSession: false,
+		},
+	},
+);
+export default supabaseAdmin;
+`;
+
+//#endregion
+//#region src/configs/expressjs/supabase_local.ts
+async function configSupabaseLocal(projectDir) {
+	execa("npx", ["supabase", "init"], {
+		cwd: projectDir,
+		stdio: "inherit"
+	});
+	const migrationsDir = path.join(projectDir, "supabase", "migrations");
+	const schemaDir = path.join(projectDir, "supabase", "schemas");
+	const dbDir = path.join(schemaDir, "db");
+	const storageDir = path.join(schemaDir, "storage");
+	await Promise.all([fs.ensureDir(migrationsDir), fs.ensureDir(schemaDir)]);
+	await Promise.all([fs.ensureDir(dbDir), fs.ensureDir(storageDir)]);
+}
+
+//#endregion
+//#region src/configs/expressjs/drizzle.ts
+async function configDrizzle(projectName) {
+	const schemasDir = path.join(projectName, "src", "db", "schemas");
+	const migrationsDir = path.join(projectName, "src", "db", "migrations");
+	const drizzleConfigPath = path.join(projectName, "drizzle.config.ts");
+	await Promise.all([
+		fs.ensureDir(schemasDir),
+		fs.ensureDir(migrationsDir),
+		fs.ensureFile(drizzleConfigPath)
+	]);
+	await fs.writeFile(drizzleConfigPath, drizzleConfigTemplate);
+	const packageJsonPath = path.join(projectName, "package.json");
+	const packageJson = await fs.readJson(packageJsonPath);
+	packageJson.scripts["db:generate"] = "npx drizzle-kit generate --config=./drizzle.config.ts";
+	packageJson.scripts["db:migrate"] = "npx drizzle-kit push --config=./drizzle.config.ts";
+	packageJson.scripts["db:studio"] = "npx drizzle-kit studio --verbose --config=./drizzle.config.ts";
+	packageJson.scripts["db:pull"] = "npx drizzle-kit pull --config=./drizzle.config.ts";
+	packageJson.scripts["db:check"] = "npx drizzle-kit check --config=./drizzle.config.ts";
+	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+}
+const drizzleConfigTemplate = `import { defineConfig } from "drizzle-kit";
+import { env } from "./src/env";
+
+export default defineConfig({
+	dialect: "postgresql",
+	schema: "./src/db/schemas/*",
+	out: "./src/db/migrations",
+	dbCredentials: {
+		url: env.DATABASE_URL,
+	},
+	verbose: true,
+	strict: true,
+});
+`.trimStart();
+
+//#endregion
+//#region src/configs/expressjs/biome.ts
+async function configBiome(projectName) {
+	execa("npx", ["biome", "init"], {
+		cwd: projectName,
+		stdio: "inherit"
+	});
+}
+
+//#endregion
+//#region src/configs/expressjs/jest.ts
+async function configJest(projectName) {
+	const jestConfigPath = path.join(projectName, "jest.config.mjs");
+	await fs.ensureFile(jestConfigPath);
+	await fs.writeFile(jestConfigPath, jestConfigTemplate);
+	const packageJsonPath = path.join(projectName, "package.json");
+	const packageJson = await fs.readJson(packageJsonPath);
+	packageJson.scripts["test:unit"] = "jest --testPathPatterns=unit";
+	packageJson.scripts["test:integration"] = "jest --testPathPatterns=integration";
+	packageJson.scripts["test"] = "jest";
+	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+	const testUnitDir = path.join(projectName, "test", "unit");
+	const testIntegrationDir = path.join(projectName, "test", "integration");
+	await Promise.all([fs.ensureDir(testUnitDir), fs.ensureDir(testIntegrationDir)]);
+}
+const jestConfigTemplate = `/** @type {import('jest').Config} */
+
+export default {
+	clearMocks: true,
+	coverageProvider: "v8",
+	moduleNameMapper: {
+		"^@/(.*)$": "<rootDir>/src/$1",
+	},
+	preset: "ts-jest/presets/default-esm",
+	testEnvironment: "node",
+};
+`.trimStart();
+
+//#endregion
+//#region src/configs/expressjs/typescript.ts
+async function configTypescript(projectName) {
+	await execa("npx", ["tsc", "--init"], {
+		cwd: projectName,
+		stdio: "inherit"
+	});
+	const tsconfigPath = path.join(projectName, "tsconfig.json");
+	await fs.writeFile(tsconfigPath, tsconfigTemplate);
+	const packageJsonPath = path.join(projectName, "package.json");
+	const packageJson = await fs.readJson(packageJsonPath);
+	packageJson.scripts["start"] = "node ./dist/index.js";
+	packageJson.scripts["build"] = "tsc --build";
+	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+}
+const tsconfigTemplate = `{
+	"compilerOptions": {
+		"rootDir": ".",
+		"outDir": "./dist",
+
+		"module": "CommonJS",
+		"target": "ES2022",
+		"esModuleInterop": true,
+		"resolveJsonModule": true,
+		"types": ["jest"],
+
+		"sourceMap": true,
+		"declaration": true,
+		"declarationMap": true,
+
+		"noUncheckedIndexedAccess": true,
+		"exactOptionalPropertyTypes": true,
+
+		"strict": true,
+		"isolatedModules": true,
+		"noUncheckedSideEffectImports": true,
+		"moduleDetection": "force",
+		"skipLibCheck": true
+	}
+}`.trimStart();
+
+//#endregion
+//#region src/configs/expressjs/nodemon.ts
+async function configNodemon(projectName) {
+	const packageJsonPath = path.join(projectName, "package.json");
+	const packageJson = await fs.readJson(packageJsonPath);
+	packageJson.scripts["dev"] = "nodemon index.ts";
+	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+}
+
+//#endregion
+//#region src/setup/expressjs.ts
+async function setupExpressjs(projectName, dbProvider, dbTool, isNeverThrow) {
+	await createExpressApp(projectName);
+	const dependencies = [
+		"cookie-parser",
+		"cors",
+		"dotenv",
+		"drizzle-orm",
+		"express",
+		"helmet",
+		"morgan",
+		"swagger-ui-express",
+		"zod"
+	];
+	const devDependencies = [
+		"@biomejs/biome",
+		"@types/cookie-parser",
+		"@types/cors",
+		"@types/dotenv",
+		"@types/express",
+		"@types/helmet",
+		"@types/jest",
+		"@types/morgan",
+		"@types/swagger-ui-express",
+		"husky",
+		"jest",
+		"lint-staged",
+		"nodemon",
+		"ts-jest",
+		"ts-node",
+		"typescript"
+	];
+	if (dbProvider === DB_PROVIDERS.SUPABASE) dependencies.push("@supabase/supabase-js");
+	if (dbTool === DB_TOOLS.DRIZZLE_ORM) {
+		dependencies.push("drizzle-orm", "postgres");
+		devDependencies.push("drizzle-kit");
+	}
+	if (isNeverThrow) dependencies.push("neverthrow");
+	await installDependencies$1(projectName, dependencies);
+	await installDevDependencies$1(projectName, devDependencies);
+	await setupHuskyLintStaged(projectName);
+	await configEnv(projectName, dbProvider === DB_PROVIDERS.SUPABASE);
+	if (dbProvider === DB_PROVIDERS.DOCKER) await setupDockerPostgres(projectName);
+	if (dbProvider === DB_PROVIDERS.SUPABASE) await configSupabaseClient(projectName);
+	if (dbTool === DB_TOOLS.SUPABASE_JS_SDK) await configSupabaseLocal(projectName);
+	if (dbTool === DB_TOOLS.DRIZZLE_ORM) await configDrizzle(projectName);
+	await configBiome(projectName);
+	await configJest(projectName);
+	await configTypescript(projectName);
+	await configNodemon(projectName);
+}
+
+//#endregion
+//#region src/installers/nextjs/dependencies.ts
+async function installDependencies(projectName, dependencies) {
+	await execa("npm", ["install", ...dependencies], {
+		cwd: projectName,
+		stdio: "inherit"
+	});
+}
+
+//#endregion
+//#region src/installers/nextjs/devDependencies.ts
+async function installDevDependencies(projectName, devDependencies) {
+	await execa("npm", [
+		"install",
+		"-D",
+		...devDependencies
+	], {
+		cwd: projectName,
+		stdio: "inherit"
+	});
+}
+
+//#endregion
+//#region src/installers/nextjs/nexjs.ts
+async function createNextApp(projectName) {
+	await execa("npx", [
+		"create-next-app@latest",
+		projectName,
+		"--ts",
+		"--tailwind",
+		"--react-compiler",
+		"--biome",
+		"--app",
+		"--src-dir",
+		"--import-alias",
+		"@/*"
+	], { stdio: "inherit" });
+}
+
+//#endregion
+//#region src/setup/nextjs.ts
+async function setupNextjs(projectName, dbProvider, dbTool, uiLibrary, isNeverThrow) {
+	await createNextApp(projectName);
+	const dependencies = [
+		"react-hook-form",
+		"@hookform/resolvers",
+		"zod",
+		"server-only"
+	];
+	const devDependencies = [
+		"husky",
+		"lint-staged",
+		"jest",
+		"@types/jest",
+		"ts-jest"
+	];
+	if (dbProvider === DB_PROVIDERS.SUPABASE) dependencies.push("@supabase/ssr", "@supabase/supabase-js");
+	if (dbTool === DB_TOOLS.DRIZZLE_ORM) {
+		dependencies.push("drizzle-orm", "postgres");
+		devDependencies.push("drizzle-kit");
+	}
+	if (isNeverThrow) dependencies.push("neverthrow");
+	await installDependencies(projectName, dependencies);
+	await installDevDependencies(projectName, devDependencies);
+	await setupHuskyLintStaged(projectName);
+	await setupEnv(projectName, dbProvider === DB_PROVIDERS.SUPABASE);
+	if (dbProvider === DB_PROVIDERS.SUPABASE) await setupSupabaseClient(projectName);
+	if (dbProvider === DB_PROVIDERS.DOCKER) await setupDockerPostgres(projectName);
+	if (dbTool === DB_TOOLS.SUPABASE_JS_SDK) await setupSupabaseLocal(projectName);
+	if (dbTool === DB_TOOLS.DRIZZLE_ORM) await setupDrizzle(projectName);
+	if (uiLibrary === UI_LIB.SHADCN) await setupShadcn(projectName);
+	await setupBiome(projectName, uiLibrary === UI_LIB.SHADCN);
+	await setupJest(projectName);
+}
+
 //#endregion
 //#region src/create.ts
 async function createProject(answers) {
-	const { projectName, framework, dbProvider, dbTool, uiLibrary, useMonorepo } = answers;
+	const { projectName, framework, dbProvider, dbTool, uiLibrary, isNeverThrow } = answers;
 	switch (framework) {
-		case FRAMEWORKS.NEXT: {
-			await createNextApp(projectName);
-			const isSupabase = dbProvider === DB_PROVIDERS.SUPABASE;
-			const dependencies = [
-				"react-hook-form",
-				"@hookform/resolvers",
-				"zod",
-				"server-only"
-			];
-			const devDependencies = [
-				"husky",
-				"lint-staged",
-				"jest",
-				"@types/jest",
-				"ts-jest"
-			];
-			if (isSupabase) dependencies.push("@supabase/ssr", "@supabase/supabase-js");
-			if (dbTool === DB_TOOLS.DRIZZLE_ORM) {
-				dependencies.push("drizzle-orm", "postgres");
-				devDependencies.push("drizzle-kit");
-			}
-			await installDependencies(projectName, dependencies);
-			await installDevDependencies(projectName, devDependencies);
-			await setupHuskyLintStaged(projectName);
-			await setupNextEnv(projectName, isSupabase);
-			if (isSupabase) await setupNextSupabaseClient(projectName);
-			if (dbTool === DB_TOOLS.SUPABASE_JS_SDK) await setupNextSupabaseLocal(projectName);
-			if (dbTool === DB_TOOLS.DRIZZLE_ORM) await setupDrizzle(projectName);
-			if (uiLibrary === UI_LIB.SHADCN) await setupShadcn(projectName);
-			await setupBiome(projectName, uiLibrary === UI_LIB.SHADCN);
-			await setupJest(projectName);
+		case FRAMEWORKS.NEXT:
+			await setupNextjs(projectName, dbProvider, dbTool, uiLibrary, isNeverThrow);
 			break;
-		}
 		case FRAMEWORKS.NEXT_EXPRESS:
-			createNextApp(projectName + "-fe");
-			createNextExpressApp(projectName + "-be");
+			await Promise.all([setupNextjs(projectName + "-fe", DB_PROVIDERS.NONE, DB_TOOLS.NONE, uiLibrary, isNeverThrow), setupExpressjs(projectName + "-be", dbProvider, dbTool, isNeverThrow)]);
 			break;
 		case FRAMEWORKS.NEXT_NEST:
-			createNextApp(projectName + "-fe");
+			await setupNextjs(projectName + "-fe", DB_PROVIDERS.NONE, DB_TOOLS.NONE, uiLibrary, isNeverThrow);
 			createNestApp(projectName + "-be");
 			break;
 		case FRAMEWORKS.REACT_EXPRESS:
 			createReactApp(projectName + "-fe");
-			createNextExpressApp(projectName + "-be");
+			createExpressApp(projectName + "-be");
 			break;
 		case FRAMEWORKS.REACT_NEST:
 			createReactApp(projectName + "-fe");
@@ -506,10 +894,9 @@ async function ask() {
 		},
 		{
 			type: "confirm",
-			name: "useMonorepo",
-			message: "Do you want to use monorepo?",
-			default: true,
-			when: (answers) => ![FRAMEWORKS.NEXT, FRAMEWORKS.REACT].includes(answers.framework)
+			name: "isNeverThrow",
+			message: "Do you want to use nerverthrow?",
+			default: false
 		}
 	]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-init-mtv-app",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "CLI for create init app",
   "keywords": [
     "create-init-app"