create-vitnode-app 1.2.0-canary.8 → 2.0.0-canary.1

package/dist/src/create/create-package-json.js

@@ -1,66 +1,276 @@
-import { readFile, writeFile } from 'fs/promises';
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-export const createPackageJSON = async ({ appName, packageManager, root, eslint, }) => {
-    const pkg = JSON.parse(await readFile(join(__dirname, '..', '..', '..', 'package.json'), 'utf-8'));
-    const packageJson = {
-        name: appName,
-        version: '0.1.0',
+import { writeFile } from "fs/promises";
+import { join } from "path";
+import { getAvailablePackageManagers } from "../helpers/get-available-package-managers.js";
+import { getVitnodePackageVersion } from "../helpers/get-vitnode-package-version.js";
+import { withIf } from "../helpers/with-If.js";
+import { versionsPackageJson } from "./package-versions.js";
+const writeJson = async (path, data) => writeFile(path, JSON.stringify(data, null, 2));
+const paths = (root) => ({
+    root,
+    api: join(root, "apps", "api"),
+    web: join(root, "apps", "web"),
+});
+const eslintScripts = {
+    lint: "eslint .",
+    "lint:fix": "eslint . --fix",
+};
+const i18nScripts = {
+    "i18n:create": "vitnode i18n:create",
+    "i18n:check": "vitnode i18n:check",
+    "i18n:delete": "vitnode i18n:delete",
+    "i18n:update": "vitnode i18n:update",
+    "i18n:update:ai": "vitnode i18n:update:ai",
+};
+const dockerDevScript = (appName) => `docker compose -f ./docker-compose.yml -p ${appName}-vitnode-dev up -d`;
+export const rootScripts = (enableEslint, enableDocker, appName) => ({
+    "db:migrate": "turbo db:migrate",
+    "db:prepare": "turbo db:prepare",
+    dev: "turbo db:prepare && turbo dev",
+    build: "turbo build",
+    start: "turbo start",
+    "i18n:create": "turbo i18n:create",
+    "i18n:check": "turbo i18n:check",
+    "i18n:delete": "turbo i18n:delete",
+    "i18n:update": "turbo i18n:update",
+    "i18n:update:ai": "turbo i18n:update:ai",
+    ...withIf(enableEslint, {
+        lint: "turbo lint",
+        "lint:fix": "turbo lint:fix",
+    }),
+    ...withIf(enableDocker, { "docker:dev": dockerDevScript(appName) }),
+});
+export const apiScripts = (pm, eslint, docker, onlyApi, appName) => {
+    return {
+        "db:migrate": "vitnode migrate",
+        "db:prepare": "vitnode db:prepare",
+        ...(pm === "bun"
+            ? {
+                dev: "vitnode db:prepare && bun run --hot src/index.ts",
+                start: "NODE_ENV=production bun run src/index.ts",
+            }
+            : {
+                dev: "vitnode db:prepare && tsx watch src/index.ts",
+                build: "tsc && tsc-alias -p tsconfig.json",
+                start: "node dist/index.js",
+            }),
+        "dev:email": "email dev --dir src/emails",
+        ...i18nScripts,
+        ...withIf(eslint, eslintScripts),
+        ...withIf(docker && onlyApi, { "docker:dev": dockerDevScript(appName) }),
+        "drizzle-kit": "drizzle-kit",
+    };
+};
+export const singleAppScripts = (eslint, docker, appName) => ({
+    "db:migrate": "vitnode migrate",
+    "db:prepare": "vitnode db:prepare",
+    dev: "vitnode db:prepare && vite dev --port 3000",
+    "dev:email": "email dev --dir src/emails",
+    build: "vite build",
+    start: "node .output/server/index.mjs",
+    ...i18nScripts,
+    ...withIf(eslint, eslintScripts),
+    ...withIf(docker, { "docker:dev": dockerDevScript(appName) }),
+    "drizzle-kit": "drizzle-kit",
+});
+export const webScripts = (eslint) => ({
+    dev: "vite dev --port 3000",
+    build: "vite build",
+    start: "node .output/server/index.mjs",
+    ...i18nScripts,
+    ...withIf(eslint, eslintScripts),
+});
+const baseDevDeps = (eslint, includePrettier) => ({
+    "@types/node": versionsPackageJson.typesNode,
+    "@vitnode/config": "",
+    ...withIf(eslint, {
+        eslint: versionsPackageJson.eslint,
+        ...withIf(includePrettier, {
+            prettier: versionsPackageJson.prettier,
+            "prettier-plugin-tailwindcss": versionsPackageJson.prettierTailwind,
+        }),
+    }),
+});
+const rootDevDeps = (eslint) => ({
+    ...baseDevDeps(eslint, true),
+    turbo: versionsPackageJson.turbo,
+    typescript: versionsPackageJson.typescript,
+    zod: versionsPackageJson.zod,
+});
+const apiDeps = {
+    "@hono/zod-openapi": versionsPackageJson.honoZodOpenapi,
+    "@hono/zod-validator": versionsPackageJson.honoZodValidator,
+    "@vitnode/core": "",
+    "drizzle-kit": versionsPackageJson.drizzleKit,
+    "drizzle-orm": versionsPackageJson.drizzleOrm,
+    hono: versionsPackageJson.hono,
+    react: versionsPackageJson.react,
+    "react-dom": versionsPackageJson.reactDom,
+    "react-email": versionsPackageJson.reactEmail,
+    ws: versionsPackageJson.ws,
+    zod: versionsPackageJson.zod,
+};
+const apiDevDeps = (pm, eslint) => ({
+    "@hono/node-server": "^2.0",
+    "@react-email/ui": versionsPackageJson.reactEmailUi,
+    ...(pm === "bun" ? { "@types/bun": versionsPackageJson.typesBun } : {}),
+    "@types/node": versionsPackageJson.typesNode,
+    "@types/react": versionsPackageJson.typesReact,
+    "@types/react-dom": versionsPackageJson.typesReactDom,
+    "@vitnode/config": "",
+    dotenv: versionsPackageJson.dotenv,
+    ...withIf(eslint, {
+        eslint: versionsPackageJson.eslint,
+    }),
+    "tsc-alias": versionsPackageJson.tscAlias,
+    tsx: versionsPackageJson.tsx,
+    typescript: versionsPackageJson.typescript,
+});
+const tanstackWebDeps = {
+    "@tailwindcss/vite": versionsPackageJson.tailwindVite,
+    "@tanstack/react-query": versionsPackageJson.tanstackReactQuery,
+    "@tanstack/react-router": versionsPackageJson.tanstackReactRouter,
+    "@tanstack/react-router-ssr-query": versionsPackageJson.tanstackRouterSsrQuery,
+    "@tanstack/react-start": versionsPackageJson.tanstackReactStart,
+    "@vitnode/core": "",
+    "lucide-react": versionsPackageJson.lucide,
+    nitro: versionsPackageJson.nitro,
+    react: versionsPackageJson.react,
+    "react-dom": versionsPackageJson.reactDom,
+    "react-hook-form": versionsPackageJson.rhf,
+    sonner: versionsPackageJson.sonner,
+    tailwindcss: versionsPackageJson.tailwind,
+    tslib: versionsPackageJson.tslib,
+    "use-intl": versionsPackageJson.useIntl,
+    zod: versionsPackageJson.zod,
+};
+const singleAppDeps = {
+    ...tanstackWebDeps,
+    "@hono/zod-openapi": versionsPackageJson.honoZodOpenapi,
+    "@hono/zod-validator": versionsPackageJson.honoZodValidator,
+    "@hookform/resolvers": versionsPackageJson.rhfResolvers,
+    "drizzle-kit": versionsPackageJson.drizzleKit,
+    "drizzle-orm": versionsPackageJson.drizzleOrm,
+    hono: versionsPackageJson.hono,
+    "react-email": versionsPackageJson.reactEmail,
+    shadcn: versionsPackageJson.shadcn,
+};
+const tanstackWebDevDeps = {
+    "@tanstack/devtools-vite": versionsPackageJson.tanstackDevtoolsVite,
+    "@tanstack/react-devtools": versionsPackageJson.tanstackReactDevtools,
+    "@tanstack/react-query-devtools": versionsPackageJson.tanstackQueryDevtools,
+    "@tanstack/react-router-devtools": versionsPackageJson.tanstackRouterDevtools,
+    "@types/node": versionsPackageJson.typesNode,
+    "@types/react": versionsPackageJson.typesReact,
+    "@types/react-dom": versionsPackageJson.typesReactDom,
+    "@vitejs/plugin-react": versionsPackageJson.viteReact,
+    "@vitnode/config": "",
+    "tw-animate-css": versionsPackageJson.twAnimateCss,
+    typescript: versionsPackageJson.typescript,
+    vite: versionsPackageJson.vite,
+};
+const singleAppDevDeps = (eslint) => ({
+    ...tanstackWebDevDeps,
+    "@react-email/ui": versionsPackageJson.reactEmailUi,
+    ...withIf(eslint, {
+        eslint: versionsPackageJson.eslint,
+        prettier: versionsPackageJson.prettier,
+        "prettier-plugin-tailwindcss": versionsPackageJson.prettierTailwind,
+    }),
+    turbo: versionsPackageJson.turbo,
+});
+const webDeps = {
+    ...tanstackWebDeps,
+    shadcn: versionsPackageJson.shadcn,
+};
+const webDevDeps = (eslint) => ({
+    ...tanstackWebDevDeps,
+    "@hookform/resolvers": versionsPackageJson.rhfResolvers,
+    "class-variance-authority": versionsPackageJson.cva,
+    ...withIf(eslint, { eslint: versionsPackageJson.eslint }),
+});
+export const createPackageJSON = async ({ appName, packageManager, root, eslint, docker, mode, monorepo, }) => {
+    const vitnodeVersionRange = await getVitnodePackageVersion();
+    const pmVersions = await getAvailablePackageManagers();
+    const pmSpec = `${packageManager}@${pmVersions[packageManager]}`;
+    const p = paths(root);
+    const isApiMonorepo = mode === "apiMonorepo" || !!monorepo;
+    const isOnlyApi = mode === "onlyApi";
+    const isSingleApp = mode === "singleApp";
+    if (isApiMonorepo) {
+        const rootPkg = {
+            name: appName,
+            private: true,
+            scripts: rootScripts(eslint, !!docker, appName),
+            devDependencies: {
+                ...rootDevDeps(eslint),
+                "@vitnode/config": vitnodeVersionRange,
+            },
+            packageManager: pmSpec,
+            workspaces: ["apps/*", "plugins/*"],
+        };
+        await writeJson(join(p.root, "package.json"), rootPkg);
+    }
+    const apiPkg = {
+        name: isApiMonorepo ? "api" : appName,
+        version: "0.1.0",
         private: true,
-        type: 'module',
-        scripts: {
-            'drizzle-kit': 'drizzle-kit',
-            'db:push': 'drizzle-kit push',
-            'db:migrate': 'drizzle-kit up && drizzle-kit generate && drizzle-kit migrate',
-            dev: 'vitnode init && next dev --turbopack',
-            build: 'next build --turbopack',
-            start: 'next start',
-            ...(eslint
-                ? {
-                    lint: 'eslint .',
-                    'lint:fix': 'eslint . --fix',
-                }
-                : {}),
-        },
+        type: "module",
+        scripts: apiScripts(packageManager, eslint, !!docker, mode === "onlyApi", appName),
         dependencies: {
-            '@hono/zod-openapi': '^0.19.8',
-            '@hono/zod-validator': '^0.7.0',
-            '@hookform/resolvers': '^5.0.1',
-            '@react-email/components': '^0.0.41',
-            '@vitnode/core': `^${pkg.version}`,
-            'babel-plugin-react-compiler': '19.1.0-rc.2',
-            'drizzle-kit': '^0.31.1',
-            'drizzle-orm': '^0.44.1',
-            hono: '^4.7.10',
-            'lucide-react': '^0.511.0',
-            next: '^15.3.3',
-            'next-intl': '^4.1.0',
-            react: '^19.1.0',
-            'react-dom': '^19.1.0',
-            'react-hook-form': '^7.56.4',
-            sonner: '^2.0.3',
-            zod: '^3.25.42',
+            ...apiDeps,
+            "@vitnode/core": vitnodeVersionRange,
         },
         devDependencies: {
-            '@tailwindcss/postcss': '^4.1.8',
-            '@types/node': '^22.15.29',
-            '@types/react': '^19.1.6',
-            '@types/react-dom': '^19.1.5',
-            ...(eslint
+            ...apiDevDeps(packageManager, eslint),
+            "@vitnode/config": vitnodeVersionRange,
+            ...(eslint && mode === "onlyApi"
                 ? {
-                    eslint: '^9.27.0',
-                    'eslint-config-typescript-vitnode': `^${pkg.version}`,
-                    prettier: '^3.5.3',
+                    prettier: versionsPackageJson.prettier,
+                    "prettier-plugin-tailwindcss": versionsPackageJson.prettierTailwind,
                 }
                 : {}),
-            'react-email': '^4.0.15',
-            tailwindcss: '^4.1.8',
-            'tw-animate-css': '^1.3.2',
-            typescript: '^5.8.3',
+            ...(packageManager === "bun" ? {} : {}),
         },
-        packageManager,
     };
-    await writeFile(join(root, 'package.json'), JSON.stringify(packageJson, null, 2));
+    if (isSingleApp) {
+        const singlePkg = {
+            name: monorepo ? "web" : appName,
+            version: "0.1.0",
+            private: true,
+            type: "module",
+            scripts: singleAppScripts(eslint, !!docker, appName),
+            dependencies: {
+                ...singleAppDeps,
+                "@vitnode/core": vitnodeVersionRange,
+            },
+            devDependencies: {
+                ...singleAppDevDeps(eslint),
+                "@vitnode/config": vitnodeVersionRange,
+            },
+            packageManager: pmSpec,
+        };
+        await writeJson(join(monorepo ? p.web : p.root, "package.json"), singlePkg);
+    }
+    if (mode === "apiMonorepo") {
+        await writeJson(join(p.api, "package.json"), apiPkg);
+        const webPkg = {
+            name: "web",
+            version: "0.1.0",
+            private: true,
+            type: "module",
+            scripts: webScripts(eslint),
+            dependencies: {
+                ...webDeps,
+                "@vitnode/core": vitnodeVersionRange,
+            },
+            devDependencies: {
+                ...webDevDeps(eslint),
+                "@vitnode/config": vitnodeVersionRange,
+            },
+        };
+        await writeJson(join(p.web, "package.json"), webPkg);
+    }
+    if (isOnlyApi) {
+        await writeJson(join(monorepo ? p.api : p.root, "package.json"), apiPkg);
+    }
 };

package/dist/src/create/create-vitnode.js

@@ -1,55 +1,204 @@
-import { randomBytes } from 'crypto';
-import { existsSync } from 'fs';
-import { copyFile, cp, mkdir, readFile, rename, writeFile } from 'fs/promises';
-import ora from 'ora';
-import { dirname, join } from 'path';
-import color from 'picocolors';
-import { fileURLToPath } from 'url';
-import { installDependencies } from '../helpers/install-dependencies.js';
-import { isFolderEmpty } from '../helpers/is-folder-empty.js';
-import { createPackageJSON } from './create-package-json.js';
-export const createVitNode = async ({ root, appName, packageManager, eslint, install, }) => {
+import { existsSync } from "node:fs";
+import { copyFile, cp, mkdir, readFile, rename, writeFile, } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import ora from "ora";
+import color from "picocolors";
+import { generateMigrationsVitnode } from "../helpers/init-vitnode.js";
+import { installDependencies } from "../helpers/install-dependencies.js";
+import { isFolderEmpty } from "../helpers/is-folder-empty.js";
+import { createPackageJSON } from "./create-package-json.js";
+export const createVitNode = async ({ root, appName, packageManager, eslint, install, docker, mode, monorepo, }) => {
     const spinner = ora(`Creating a new VitNode app in ${color.green(root)}. Using ${color.green(packageManager)}...`).start();
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = dirname(__filename);
-    const templatePath = join(__dirname, '..', '..', '..', 'copy-of-vitnode-app');
+    const templatePath = join(__dirname, "..", "..", "..", "copy-of-vitnode-app");
     if (!existsSync(templatePath)) {
-        spinner.fail(`\n${color.red('Error!')} Template path ${color.cyan(templatePath)} does not exist.`);
+        spinner.fail(`\n${color.red("Error!")} Template path ${color.cyan(templatePath)} does not exist.`);
         process.exit(1);
     }
     await mkdir(root, { recursive: true });
     if (!isFolderEmpty(root, appName)) {
         process.exit(1);
     }
-    spinner.text = 'Copying files...';
-    await cp(join(templatePath, 'root'), root, {
+    const monorepoStructure = {
+        api: join(root, "apps", "api"),
+        web: join(root, "apps", "web"),
+    };
+    spinner.text = "Preparing the project structure...";
+    if (monorepo || mode === "apiMonorepo") {
+        monorepo = true;
+        const dirsToCreate = [];
+        if (mode === "apiMonorepo" || (monorepo && mode === "onlyApi")) {
+            dirsToCreate.push(monorepoStructure.api);
+        }
+        if (mode === "apiMonorepo" || (monorepo && mode === "singleApp")) {
+            dirsToCreate.push(monorepoStructure.web);
+        }
+        await Promise.all(dirsToCreate.map(async (dir) => mkdir(dir, { recursive: true })));
+    }
+    spinner.text = "Copying files...";
+    await cp(join(templatePath, ".vscode"), join(root, ".vscode"), {
         recursive: true,
     });
-    if (eslint) {
-        spinner.text = 'Copying eslint files...';
-        await cp(join(templatePath, 'eslint'), root, {
+    if (mode === "singleApp") {
+        const destination = monorepo ? monorepoStructure.web : root;
+        await cp(join(templatePath, "root"), destination, { recursive: true });
+        await cp(join(templatePath, "api-single-app"), destination, {
+            recursive: true,
+        });
+    }
+    else if (mode === "apiMonorepo") {
+        await Promise.all([
+            cp(join(templatePath, "root"), monorepoStructure.web, {
+                recursive: true,
+            }),
+            cp(join(templatePath, "api"), monorepoStructure.api, {
+                recursive: true,
+            }),
+        ]);
+        if (packageManager === "bun") {
+            await cp(join(templatePath, "api-bun"), monorepoStructure.api, {
+                recursive: true,
+            });
+        }
+    }
+    else if (mode === "onlyApi") {
+        await cp(join(templatePath, "api"), monorepo ? monorepoStructure.api : root, {
+            recursive: true,
+        });
+        if (packageManager === "bun") {
+            await cp(join(templatePath, "api-bun"), monorepo ? monorepoStructure.api : root, {
+                recursive: true,
+            });
+        }
+    }
+    if (mode === "apiMonorepo" || (monorepo && mode !== "singleApp")) {
+        await cp(join(templatePath, "monorepo"), root, {
             recursive: true,
         });
     }
-    spinner.text = 'Renaming special files...';
-    await rename(join(root, 'gitignore_template'), join(root, '.gitignore'));
-    spinner.text = 'Creating package.json...';
+    else if (monorepo && mode === "singleApp") {
+        await copyFile(join(templatePath, "monorepo", "turbo.json"), join(root, "turbo.json"));
+        await copyFile(join(templatePath, "monorepo", ".gitignore_template"), join(root, ".gitignore_template"));
+    }
+    if (eslint) {
+        spinner.text = "Copying ESLint & Prettier files...";
+        if (monorepo) {
+            if (existsSync(monorepoStructure.api)) {
+                await cp(join(templatePath, "eslint"), monorepoStructure.api, {
+                    recursive: true,
+                });
+            }
+            if (existsSync(monorepoStructure.web)) {
+                await cp(join(templatePath, "eslint-react"), monorepoStructure.web, {
+                    recursive: true,
+                });
+            }
+        }
+        else {
+            if (mode === "onlyApi") {
+                await cp(join(templatePath, "eslint"), root, {
+                    recursive: true,
+                });
+            }
+            else if (mode === "singleApp") {
+                await cp(join(templatePath, "eslint-react"), root, {
+                    recursive: true,
+                });
+            }
+        }
+    }
+    spinner.text = "Renaming special files...";
+    await rename(join(root, ".gitignore_template"), join(root, ".gitignore"));
+    if (mode === "apiMonorepo" || monorepo) {
+        if (existsSync(join(monorepoStructure.api, ".gitignore_template"))) {
+            await rename(join(monorepoStructure.api, ".gitignore_template"), join(monorepoStructure.api, ".gitignore"));
+        }
+        if (existsSync(join(monorepoStructure.web, ".gitignore_template"))) {
+            await rename(join(monorepoStructure.web, ".gitignore_template"), join(monorepoStructure.web, ".gitignore"));
+        }
+    }
+    spinner.text = "Creating package.json...";
     await createPackageJSON({
         root,
         appName,
         packageManager,
         eslint,
+        docker,
+        mode,
+        monorepo,
     });
-    spinner.text = 'Changing .env file...';
-    await copyFile(join(root, '.env.template'), join(root, '.env'));
-    const envPath = join(root, '.env');
-    const newEnv = (await readFile(envPath, 'utf-8')).replace('LOGIN_TOKEN_SECRET=vitnode_secret', `LOGIN_TOKEN_SECRET=${randomBytes(32).toString('hex')}`);
-    await writeFile(envPath, newEnv);
+    if ((mode === "apiMonorepo" || monorepo) && packageManager === "pnpm") {
+        spinner.text = "Creating pnpm-workspace.yaml...";
+        const pnpmWorkspaceContent = `packages:\n  - 'apps/*'\n  - 'plugins/*'\n`;
+        await writeFile(join(root, "pnpm-workspace.yaml"), pnpmWorkspaceContent);
+    }
+    if (docker) {
+        spinner.text = "Copying docker files...";
+        await copyFile(join(templatePath, "docker", "docker-compose.yml"), join(root, "docker-compose.yml"));
+        const dockerComposePath = join(root, "docker-compose.yml");
+        const dockerComposeContent = await readFile(dockerComposePath, "utf-8");
+        const updatedContent = dockerComposeContent.replace(/vitnode_postgres_dev/g, `${appName}_vitnode_postgres_dev`);
+        await writeFile(dockerComposePath, updatedContent);
+    }
+    spinner.text = "Updating VitNode paths...";
+    if ((mode === "apiMonorepo" || monorepo) &&
+        packageManager === "npm" &&
+        mode !== "onlyApi") {
+        const stylesPath = join(monorepoStructure.web, "src", "styles.css");
+        const stylesContent = await readFile(stylesPath, "utf-8");
+        await writeFile(stylesPath, stylesContent.replaceAll('@source "../node_modules/@vitnode/', '@source "../../../node_modules/@vitnode/'));
+    }
+    if (mode === "apiMonorepo") {
+        spinner.text = "Setting up environment variables...";
+        const envExamplePath = join(monorepoStructure.web, ".env.example");
+        if (existsSync(envExamplePath)) {
+            await rename(envExamplePath, join(monorepoStructure.web, ".env"));
+        }
+    }
     if (install) {
-        spinner.text = 'Installing dependencies...';
+        spinner.text = "Installing dependencies...";
         await installDependencies({
             packageManager,
+            cwd: root,
         });
+        spinner.text = "Preparing README...";
+        await copyFile(join(templatePath, "README.md"), join(root, "README.md"));
+        let readmeContent = await readFile(join(root, "README.md"), "utf-8");
+        readmeContent = readmeContent.replaceAll("pnpm", packageManager);
+        let startUrlsText = "[http://localhost:3000](http://localhost:3000)";
+        if (mode === "onlyApi") {
+            startUrlsText = "[http://localhost:8000](http://localhost:8000)";
+        }
+        else if (mode === "apiMonorepo") {
+            startUrlsText =
+                "[http://localhost:3000](http://localhost:3000) for the Web app and [http://localhost:8000](http://localhost:8000) for the API";
+        }
+        readmeContent = readmeContent.replace("{{START_URLS}}", startUrlsText);
+        await writeFile(join(root, "README.md"), readmeContent);
+        spinner.text = "Generating migrations...";
+        let migrationsCwd;
+        if (mode === "apiMonorepo" || (monorepo && mode !== "singleApp")) {
+            migrationsCwd = monorepoStructure.api;
+        }
+        else if (mode === "singleApp" && monorepo) {
+            migrationsCwd = monorepoStructure.web;
+        }
+        else {
+            migrationsCwd = root;
+        }
+        try {
+            await generateMigrationsVitnode({
+                packageManager,
+                cwd: migrationsCwd,
+            });
+        }
+        catch (error) {
+            spinner.fail(`${color.red("Error!")} Created ${color.cyan(appName)}, but could not generate its migrations.`);
+            console.error(color.red(error instanceof Error ? error.message : String(error)));
+            process.exit(1);
+        }
     }
-    spinner.succeed(`${color.green('Success!')} Created ${color.cyan(appName)} at ${color.cyan(root)}`);
+    spinner.succeed(`${color.green("Success!")} Created ${color.cyan(appName)} at ${color.cyan(root)}`);
 };

package/dist/src/create/package-versions.js

@@ -0,0 +1,49 @@
+export const versionsPackageJson = {
+    typesNode: "^26",
+    typesReact: "^19.2",
+    typesReactDom: "^19.2",
+    typesBun: "latest",
+    turbo: "^2.10",
+    typescript: "^6.0",
+    tsx: "^4",
+    tscAlias: "^1.9",
+    eslint: "^10",
+    prettier: "^3.9",
+    prettierTailwind: "^0.8",
+    tailwind: "^4.2",
+    twAnimateCss: "^1.4.0",
+    react: "^19.2",
+    reactDom: "^19.2",
+    useIntl: "^4.13.7",
+    rhf: "^7",
+    rhfResolvers: "^5.1.1",
+    lucide: "^1.21",
+    sonner: "^2.0.7",
+    dotenv: "^17.4",
+    drizzleKit: "1.0.0-rc.4",
+    drizzleOrm: "1.0.0-rc.4",
+    hono: "^4.12",
+    honoZodOpenapi: "^1.5",
+    honoZodValidator: "^0.9",
+    reactEmail: "^6.9",
+    reactEmailUi: "^6.9",
+    zod: "^4.4",
+    ws: "^8",
+    cva: "^0.7.1",
+    tanstackReactRouter: "^1.170",
+    tanstackReactStart: "^1.168",
+    tanstackReactQuery: "^5.101",
+    tanstackRouterSsrQuery: "^1.167",
+    tanstackReactDevtools: "^0.10",
+    tanstackDevtoolsVite: "^0.8",
+    tanstackQueryDevtools: "^5.102",
+    tanstackRouterDevtools: "^1.167",
+    vite: "^8.0",
+    viteReact: "^6.0",
+    tailwindVite: "^4.2",
+    nitro: "3.0.260610-beta",
+    tslib: "^2.8.1",
+    swcCli: "^0.8.1",
+    swcCore: "^1.15",
+    shadcn: "^4",
+};

package/dist/src/helpers/get-available-package-managers.js

@@ -1,20 +1,20 @@
-import { exec } from 'child_process';
+import { exec } from "node:child_process";
 export const execShellCommand = async (cmd) => {
-    return new Promise(resolve => {
+    return await new Promise(resolve => {
         exec(cmd, (error, stdout, stderr) => {
             if (error) {
                 resolve(undefined);
             }
             const result = stdout ? stdout : stderr;
-            resolve(result.replace(/\s+/g, ''));
+            resolve(result.replace(/\s+/g, ""));
         });
     });
 };
 export const getAvailablePackageManagers = async () => {
     const [npm, pnpm, bun] = await Promise.all([
-        execShellCommand('npm --version'),
-        execShellCommand('pnpm --version'),
-        execShellCommand('bun --version'),
+        execShellCommand("npm --version"),
+        execShellCommand("pnpm --version"),
+        execShellCommand("bun --version"),
     ]);
     return {
         pnpm,

package/dist/src/helpers/get-package-json.js

@@ -1,2 +1,2 @@
-import { readFileSync } from 'fs';
-export const packageJson = JSON.parse(readFileSync(new URL('../../../package.json', import.meta.url), 'utf-8'));
+import { readFileSync } from "node:fs";
+export const packageJson = JSON.parse(readFileSync(new URL("../../../package.json", import.meta.url), "utf-8"));

package/dist/src/helpers/get-package-manager-from-root.js

@@ -0,0 +1,15 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+export const getPackageManagerFromRoot = (rootPath) => {
+    try {
+        const packageJsonPath = join(rootPath, "package.json");
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        if (packageJson.packageManager) {
+            return packageJson.packageManager.split("@")[0];
+        }
+        return "npm";
+    }
+    catch {
+        return "npm";
+    }
+};