initkit 1.1.0 → 1.2.1

package/src/utils/addonInstaller.js

@@ -0,0 +1,402 @@
+import { execCommand } from './cliRunner.js';
+import chalk from 'chalk';
+
+/**
+ * Install add-ons/libraries using their official installation methods
+ *
+ * This module installs additional libraries and tools using their
+ * official CLIs and installation commands, ensuring proper setup
+ * and configuration.
+ *
+ * @param {string} projectPath - Project directory
+ * @param {Object} config - User configuration with selected add-ons
+ * @returns {Promise<void>}
+ */
+export async function installAddons(projectPath, config) {
+  const {
+    stateManagement,
+    uiLibrary,
+    database,
+    orm,
+    authentication,
+    testing = [],
+    styling,
+    additionalLibraries = [],
+  } = config;
+
+  // State Management
+  if (stateManagement && stateManagement !== 'none') {
+    console.log(chalk.cyan('\n📦 Installing state management...'));
+    await installStateManagement(projectPath, stateManagement, config);
+  }
+
+  // UI Library
+  if (uiLibrary && uiLibrary !== 'none') {
+    console.log(chalk.cyan('\n🎨 Installing UI library...'));
+    await installUILibrary(projectPath, uiLibrary, config);
+  }
+
+  // Database & ORM
+  if (orm && orm !== 'none') {
+    console.log(chalk.cyan('\n🗄️  Installing ORM...'));
+    await installORM(projectPath, orm, database, config);
+  }
+
+  // Authentication
+  if (authentication && authentication !== 'none') {
+    console.log(chalk.cyan('\n🔐 Installing authentication...'));
+    await installAuthentication(projectPath, authentication, config);
+  }
+
+  // Testing
+  if (testing && testing.length > 0) {
+    console.log(chalk.cyan('\n🧪 Installing testing frameworks...'));
+    await installTesting(projectPath, testing, config);
+  }
+
+  // Additional libraries
+  if (additionalLibraries && additionalLibraries.length > 0) {
+    console.log(chalk.cyan('\n📦 Installing additional libraries...'));
+    for (const lib of additionalLibraries) {
+      await installAdditionalLibrary(projectPath, lib, config);
+    }
+  }
+}
+
+/**
+ * Install state management library
+ */
+async function installStateManagement(projectPath, library, config) {
+  const { packageManager } = config;
+  const installCmd = getInstallCommand(packageManager);
+
+  switch (library) {
+    case 'redux-toolkit':
+      console.log(chalk.dim('  Installing Redux Toolkit and React Redux...'));
+      await execCommand(`${installCmd} @reduxjs/toolkit react-redux`, {
+        cwd: projectPath,
+      });
+      // Store setup will be done in template generator
+      break;
+
+    case 'zustand':
+      console.log(chalk.dim('  Installing Zustand...'));
+      await execCommand(`${installCmd} zustand`, { cwd: projectPath });
+      break;
+
+    case 'jotai':
+      console.log(chalk.dim('  Installing Jotai...'));
+      await execCommand(`${installCmd} jotai`, { cwd: projectPath });
+      break;
+
+    case 'recoil':
+      console.log(chalk.dim('  Installing Recoil...'));
+      await execCommand(`${installCmd} recoil`, { cwd: projectPath });
+      break;
+
+    case 'pinia':
+      // Pinia is usually included in Vue setup
+      console.log(chalk.dim('  Pinia will be configured in Vue setup...'));
+      break;
+
+    default:
+      console.log(chalk.yellow(`  Unknown state management: ${library}`));
+  }
+}
+
+/**
+ * Install UI library (some have their own CLIs!)
+ */
+async function installUILibrary(projectPath, library, config) {
+  const { packageManager, language } = config;
+  const installCmd = getInstallCommand(packageManager);
+
+  switch (library) {
+    case 'shadcn':
+    case 'shadcn-ui':
+      console.log(chalk.dim('  Running shadcn-ui init...'));
+      // shadcn has its own CLI!
+      await execCommand(`npx shadcn@latest init -y`, { cwd: projectPath });
+      break;
+
+    case 'mui':
+    case 'material-ui':
+      console.log(chalk.dim('  Installing Material-UI...'));
+      await execCommand(
+        `${installCmd} @mui/material @emotion/react @emotion/styled @mui/icons-material`,
+        { cwd: projectPath }
+      );
+      break;
+
+    case 'antd':
+    case 'ant-design':
+      console.log(chalk.dim('  Installing Ant Design...'));
+      await execCommand(`${installCmd} antd`, { cwd: projectPath });
+      break;
+
+    case 'chakra':
+    case 'chakra-ui':
+      console.log(chalk.dim('  Installing Chakra UI...'));
+      await execCommand(
+        `${installCmd} @chakra-ui/react @emotion/react @emotion/styled framer-motion`,
+        { cwd: projectPath }
+      );
+      break;
+
+    case 'mantine':
+      console.log(chalk.dim('  Installing Mantine...'));
+      await execCommand(
+        `${installCmd} @mantine/core @mantine/hooks @mantine/form @mantine/notifications`,
+        { cwd: projectPath }
+      );
+      break;
+
+    case 'daisyui':
+      console.log(chalk.dim('  Installing DaisyUI...'));
+      await execCommand(`${installCmd} -D daisyui`, { cwd: projectPath });
+      break;
+
+    default:
+      console.log(chalk.yellow(`  Unknown UI library: ${library}`));
+  }
+}
+
+/**
+ * Install ORM (Prisma has its own CLI!)
+ */
+async function installORM(projectPath, orm, database, config) {
+  const { packageManager, language } = config;
+  const installCmd = getInstallCommand(packageManager);
+
+  switch (orm) {
+    case 'prisma': {
+      console.log(chalk.dim('  Installing Prisma...'));
+      // Prisma has its own init CLI!
+      await execCommand(`${installCmd} -D prisma`, { cwd: projectPath });
+      await execCommand(`${installCmd} @prisma/client`, { cwd: projectPath });
+
+      // Initialize Prisma with database
+      const datasource = getDatasourceForPrisma(database);
+      console.log(chalk.dim(`  Initializing Prisma with ${datasource}...`));
+      await execCommand(`npx prisma init --datasource-provider ${datasource}`, {
+        cwd: projectPath,
+      });
+      break;
+    }
+
+    case 'drizzle': {
+      console.log(chalk.dim('  Installing Drizzle ORM...'));
+      await execCommand(`${installCmd} drizzle-orm`, { cwd: projectPath });
+      await execCommand(`${installCmd} -D drizzle-kit`, { cwd: projectPath });
+
+      // Add database driver
+      const driver = getDriverForDrizzle(database);
+      console.log(chalk.dim(`  Installing database driver: ${driver}...`));
+      await execCommand(`${installCmd} ${driver}`, { cwd: projectPath });
+      break;
+    }
+
+    case 'typeorm': {
+      console.log(chalk.dim('  Installing TypeORM...'));
+      await execCommand(`${installCmd} typeorm reflect-metadata`, {
+        cwd: projectPath,
+      });
+      if (language === 'typescript') {
+        await execCommand(`${installCmd} -D @types/node`, { cwd: projectPath });
+      }
+      // Add database driver
+      const typeormDriver = getDriverForTypeORM(database);
+      if (typeormDriver) {
+        console.log(chalk.dim(`  Installing database driver: ${typeormDriver}...`));
+        await execCommand(`${installCmd} ${typeormDriver}`, {
+          cwd: projectPath,
+        });
+      }
+      break;
+    }
+
+    case 'mongoose':
+      console.log(chalk.dim('  Installing Mongoose...'));
+      await execCommand(`${installCmd} mongoose`, { cwd: projectPath });
+      if (language === 'typescript') {
+        await execCommand(`${installCmd} -D @types/mongoose`, {
+          cwd: projectPath,
+        });
+      }
+      break;
+
+    default:
+      console.log(chalk.yellow(`  Unknown ORM: ${orm}`));
+  }
+}
+
+/**
+ * Install authentication library
+ */
+async function installAuthentication(projectPath, auth, config) {
+  const { packageManager } = config;
+  const installCmd = getInstallCommand(packageManager);
+
+  switch (auth) {
+    case 'nextauth':
+    case 'next-auth':
+      console.log(chalk.dim('  Installing NextAuth.js...'));
+      await execCommand(`${installCmd} next-auth`, { cwd: projectPath });
+      break;
+
+    case 'clerk':
+      console.log(chalk.dim('  Installing Clerk...'));
+      await execCommand(`${installCmd} @clerk/nextjs`, { cwd: projectPath });
+      break;
+
+    case 'supabase':
+      console.log(chalk.dim('  Installing Supabase client...'));
+      await execCommand(`${installCmd} @supabase/supabase-js`, {
+        cwd: projectPath,
+      });
+      break;
+
+    case 'auth0':
+      console.log(chalk.dim('  Installing Auth0...'));
+      await execCommand(`${installCmd} @auth0/nextjs-auth0`, {
+        cwd: projectPath,
+      });
+      break;
+
+    case 'lucia':
+      console.log(chalk.dim('  Installing Lucia...'));
+      await execCommand(`${installCmd} lucia`, { cwd: projectPath });
+      break;
+
+    default:
+      console.log(chalk.yellow(`  Unknown authentication library: ${auth}`));
+  }
+}
+
+/**
+ * Install testing frameworks (Playwright has its own CLI!)
+ */
+async function installTesting(projectPath, testingLibs, config) {
+  const { packageManager } = config;
+  const installCmd = getInstallCommand(packageManager);
+
+  for (const lib of testingLibs) {
+    switch (lib) {
+      case 'vitest':
+        console.log(chalk.dim('  Installing Vitest...'));
+        await execCommand(`${installCmd} -D vitest`, { cwd: projectPath });
+        await execCommand(`${installCmd} -D @vitest/ui`, { cwd: projectPath });
+        break;
+
+      case 'jest':
+        console.log(chalk.dim('  Installing Jest...'));
+        await execCommand(`${installCmd} -D jest @types/jest`, {
+          cwd: projectPath,
+        });
+        break;
+
+      case 'playwright':
+        console.log(chalk.dim('  Installing Playwright...'));
+        // Playwright has its own init CLI!
+        await execCommand(`npm init playwright@latest`, { cwd: projectPath });
+        break;
+
+      case 'cypress':
+        console.log(chalk.dim('  Installing Cypress...'));
+        await execCommand(`${installCmd} -D cypress`, { cwd: projectPath });
+        break;
+
+      case 'testing-library':
+      case '@testing-library':
+        console.log(chalk.dim('  Installing React Testing Library...'));
+        await execCommand(
+          `${installCmd} -D @testing-library/react @testing-library/jest-dom @testing-library/user-event`,
+          { cwd: projectPath }
+        );
+        break;
+
+      default:
+        console.log(chalk.yellow(`  Unknown testing library: ${lib}`));
+    }
+  }
+}
+
+/**
+ * Install additional library
+ */
+async function installAdditionalLibrary(projectPath, lib, config) {
+  const { packageManager } = config;
+  const installCmd = getInstallCommand(packageManager);
+
+  console.log(chalk.dim(`  Installing ${lib}...`));
+  await execCommand(`${installCmd} ${lib}`, { cwd: projectPath });
+}
+
+/**
+ * Get install command for package manager
+ */
+function getInstallCommand(packageManager) {
+  const commands = {
+    npm: 'npm install',
+    yarn: 'yarn add',
+    pnpm: 'pnpm add',
+    bun: 'bun add',
+  };
+  return commands[packageManager] || 'npm install';
+}
+
+/**
+ * Helper functions for database mappings
+ */
+function getDatasourceForPrisma(database) {
+  if (!database || database === 'none') return 'postgresql';
+
+  const mapping = {
+    postgresql: 'postgresql',
+    postgres: 'postgresql',
+    mysql: 'mysql',
+    sqlite: 'sqlite',
+    mongodb: 'mongodb',
+    sqlserver: 'sqlserver',
+  };
+  return mapping[database.toLowerCase()] || 'postgresql';
+}
+
+function getDriverForDrizzle(database) {
+  if (!database || database === 'none') return 'pg';
+
+  const drivers = {
+    postgresql: 'pg',
+    postgres: 'pg',
+    mysql: 'mysql2',
+    sqlite: 'better-sqlite3',
+  };
+  return drivers[database.toLowerCase()] || 'pg';
+}
+
+function getDriverForTypeORM(database) {
+  if (!database || database === 'none') return null;
+
+  const drivers = {
+    postgresql: 'pg',
+    postgres: 'pg',
+    mysql: 'mysql2',
+    sqlite: 'sqlite3',
+    mongodb: 'mongodb',
+  };
+  return drivers[database.toLowerCase()] || null;
+}
+
+/**
+ * Check if user selected any add-ons
+ */
+export function hasAddons(config) {
+  return !!(
+    (config.stateManagement && config.stateManagement !== 'none') ||
+    (config.uiLibrary && config.uiLibrary !== 'none') ||
+    (config.orm && config.orm !== 'none') ||
+    (config.authentication && config.authentication !== 'none') ||
+    (config.testing && config.testing.length > 0) ||
+    (config.additionalLibraries && config.additionalLibraries.length > 0)
+  );
+}

package/src/utils/cliRunner.js

@@ -0,0 +1,146 @@
+import { spawn } from 'child_process';
+import chalk from 'chalk';
+
+/**
+ * Execute a CLI command with proper error handling and output streaming
+ *
+ * This utility function spawns a child process to run external CLI commands
+ * (like create-next-app, create-vite, etc.) while maintaining proper error
+ * handling and allowing the user to see the output in real-time.
+ *
+ * @param {string} command - The full command to execute (e.g., "npx create-next-app my-app")
+ * @param {Object} [options={}] - Execution options
+ * @param {string} [options.cwd=process.cwd()] - Working directory for the command
+ * @param {string|Array} [options.stdio='inherit'] - How to handle stdin/stdout/stderr
+ * @param {boolean} [options.shell=true] - Whether to run in a shell
+ * @param {Object} [options.env] - Environment variables
+ *
+ * @returns {Promise<void>}
+ * @throws {Error} If command execution fails
+ *
+ * @example
+ * // Bootstrap a Next.js project
+ * await execCommand('npx create-next-app@latest my-app --typescript', {
+ *   cwd: '/path/to/parent/dir'
+ * });
+ *
+ * @example
+ * // Install dependencies
+ * await execCommand('npm install @reduxjs/toolkit react-redux', {
+ *   cwd: '/path/to/project'
+ * });
+ */
+export async function execCommand(command, options = {}) {
+  const {
+    cwd = process.cwd(),
+    stdio = 'inherit',
+    shell = true,
+    env = { ...process.env, FORCE_COLOR: '1', CI: 'true' },
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    // Parse command into executable and arguments
+    const args = command.split(' ');
+    const cmd = args.shift();
+
+    const child = spawn(cmd, args, {
+      cwd,
+      stdio,
+      shell,
+      env,
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Command failed with exit code ${code}: ${chalk.red(command)}`));
+      }
+    });
+
+    child.on('error', (error) => {
+      reject(
+        new Error(`Failed to execute command: ${chalk.red(error.message)}\nCommand: ${command}`)
+      );
+    });
+  });
+}
+
+/**
+ * Execute a command and capture its output
+ *
+ * Unlike execCommand which streams output to the console, this function
+ * captures stdout and stderr and returns them as strings. Useful for
+ * commands where you need to parse the output.
+ *
+ * @param {string} command - The command to execute
+ * @param {Object} [options={}] - Execution options
+ * @param {string} [options.cwd=process.cwd()] - Working directory
+ *
+ * @returns {Promise<{stdout: string, stderr: string}>}
+ * @throws {Error} If command execution fails
+ *
+ * @example
+ * // Get npm version
+ * const { stdout } = await execCommandWithOutput('npm --version');
+ * console.log('npm version:', stdout.trim());
+ */
+export async function execCommandWithOutput(command, options = {}) {
+  const { cwd = process.cwd() } = options;
+
+  return new Promise((resolve, reject) => {
+    const args = command.split(' ');
+    const cmd = args.shift();
+
+    let stdout = '';
+    let stderr = '';
+
+    const child = spawn(cmd, args, {
+      cwd,
+      shell: true,
+      env: { ...process.env },
+    });
+
+    child.stdout?.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve({ stdout, stderr });
+      } else {
+        reject(new Error(`Command failed with exit code ${code}\nStderr: ${stderr}`));
+      }
+    });
+
+    child.on('error', (error) => {
+      reject(new Error(`Failed to execute command: ${error.message}`));
+    });
+  });
+}
+
+/**
+ * Check if a command exists in the system
+ *
+ * @param {string} command - The command to check (e.g., 'npm', 'git')
+ * @returns {Promise<boolean>}
+ *
+ * @example
+ * if (await commandExists('pnpm')) {
+ *   console.log('pnpm is installed');
+ * }
+ */
+export async function commandExists(command) {
+  const checkCmd = process.platform === 'win32' ? `where ${command}` : `which ${command}`;
+
+  try {
+    await execCommandWithOutput(checkCmd);
+    return true;
+  } catch {
+    return false;
+  }
+}