launchbase 1.0.2 → 1.0.4

package/bin/launchbase.js

@@ -6,7 +6,7 @@ const crypto = require('crypto');
 const fs = require('fs-extra');
 const { execSync, spawn } = require('child_process');
 
-const VERSION = '1.0.0';
+const VERSION = '1.0.4';
 const program = new Command();
 
 function replaceInFile(filePath, replacements) {
@@ -52,12 +52,431 @@ function checkRenderCLI() {
   }
 }
 
+function checkDocker() {
+  try {
+    execSync('docker --version', { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function checkDockerRunning() {
+  try {
+    execSync('docker info', { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getPlatform() {
+  return process.platform; // 'win32', 'darwin', 'linux'
+}
+
+async function installDocker() {
+  const platform = getPlatform();
+  console.log('\n📦 Docker not found. Installing...\n');
+  
+  if (platform === 'win32') {
+    console.log('📋 Docker Desktop for Windows\n');
+    console.log('Option 1: Install via winget (recommended)');
+    console.log('   winget install Docker.DockerDesktop\n');
+    console.log('Option 2: Download manually');
+    console.log('   https://www.docker.com/products/docker-desktop\n');
+    console.log('After installation, restart your terminal and run the command again.\n');
+    
+    // Try winget install
+    const useWinget = await askYesNo('Install via winget now?');
+    if (useWinget) {
+      console.log('\n⏳ Installing Docker Desktop via winget...');
+      console.log('   (This may take a few minutes and require UAC prompt)\n');
+      try {
+        execSync('winget install Docker.DockerDesktop --accept-package-agreements --accept-source-agreements', { 
+          stdio: 'inherit' 
+        });
+        console.log('\n✅ Docker Desktop installed!');
+        console.log('⚠️  Please restart Docker Desktop and run the command again.\n');
+        process.exit(0);
+      } catch (error) {
+        console.log('\n❌ winget install failed. Please install manually from:');
+        console.log('   https://www.docker.com/products/docker-desktop\n');
+        process.exit(1);
+      }
+    }
+  } else if (platform === 'darwin') {
+    console.log('📋 Docker Desktop for macOS\n');
+    console.log('Option 1: Install via Homebrew (recommended)');
+    console.log('   brew install --cask docker\n');
+    console.log('Option 2: Download manually');
+    console.log('   https://www.docker.com/products/docker-desktop\n');
+    
+    // Try brew install
+    try {
+      execSync('brew --version', { stdio: 'pipe' });
+      const useBrew = await askYesNo('Install via Homebrew now?');
+      if (useBrew) {
+        console.log('\n⏳ Installing Docker Desktop via Homebrew...\n');
+        execSync('brew install --cask docker', { stdio: 'inherit' });
+        console.log('\n✅ Docker Desktop installed!');
+        console.log('⚠️  Open Docker Desktop and run the command again.\n');
+        process.exit(0);
+      }
+    } catch {
+      console.log('Homebrew not found. Install manually from:');
+      console.log('   https://www.docker.com/products/docker-desktop\n');
+    }
+  } else if (platform === 'linux') {
+    console.log('� Docker for Linux\n');
+    console.log('Running official Docker install script...\n');
+    try {
+      execSync('curl -fsSL https://get.docker.com | sh', { stdio: 'inherit' });
+      console.log('\n✅ Docker installed!');
+      console.log('⚠️  Run: sudo usermod -aG docker $USER && newgrp docker\n');
+      process.exit(0);
+    } catch {
+      console.log('\n❌ Install failed. See: https://docs.docker.com/engine/install/\n');
+      process.exit(1);
+    }
+  }
+  
+  process.exit(1);
+}
+
+async function askYesNo(question) {
+  const readline = require('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  
+  return new Promise((resolve) => {
+    rl.question(`${question} (y/n): `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+
+async function ensureDocker() {
+  // Check if Docker is installed
+  if (!checkDocker()) {
+    await installDocker();
+    return false;
+  }
+  
+  // Check if Docker daemon is running
+  if (!checkDockerRunning()) {
+    const platform = getPlatform();
+    
+    console.log('\n⚠️  Docker is installed but not running.');
+    
+    // Try to start Docker Desktop automatically on Windows/macOS
+    if (platform === 'win32') {
+      console.log('🔄 Attempting to start Docker Desktop...\n');
+      try {
+        // Try to start Docker Desktop via PowerShell
+        execSync('Start-Process "C:\\Program Files\\Docker\\Docker\\Docker Desktop.exe"', {
+          shell: 'powershell.exe',
+          stdio: 'pipe'
+        });
+        
+        console.log('⏳ Waiting for Docker to start');
+        
+        // Wait for Docker to be ready (up to 60 seconds)
+        let retries = 60;
+        while (retries > 0) {
+          await new Promise(r => setTimeout(r, 1000));
+          try {
+            execSync('docker info', { stdio: 'pipe' });
+            console.log('\n✅ Docker is now running!\n');
+            return true;
+          } catch {
+            process.stdout.write('.');
+            retries--;
+          }
+        }
+        
+        console.log('\n\n⚠️  Docker did not start in time. Please start Docker Desktop manually.\n');
+        process.exit(1);
+      } catch (error) {
+        console.log('❌ Could not start Docker Desktop automatically.\n');
+        console.log('💡 Please start Docker Desktop from your Start menu and run the command again.\n');
+        process.exit(1);
+      }
+    } else if (platform === 'darwin') {
+      console.log('🔄 Attempting to start Docker Desktop...\n');
+      try {
+        execSync('open -a Docker', { stdio: 'pipe' });
+        
+        console.log('⏳ Waiting for Docker to start');
+        
+        // Wait for Docker to be ready (up to 60 seconds)
+        let retries = 60;
+        while (retries > 0) {
+          await new Promise(r => setTimeout(r, 1000));
+          try {
+            execSync('docker info', { stdio: 'pipe' });
+            console.log('\n✅ Docker is now running!\n');
+            return true;
+          } catch {
+            process.stdout.write('.');
+            retries--;
+          }
+        }
+        
+        console.log('\n\n⚠️  Docker did not start in time. Please start Docker Desktop manually.\n');
+        process.exit(1);
+      } catch (error) {
+        console.log('❌ Could not start Docker Desktop automatically.\n');
+        console.log('💡 Please start Docker Desktop from your Applications and run the command again.\n');
+        process.exit(1);
+      }
+    } else {
+      // Linux - try systemctl
+      console.log('🔄 Attempting to start Docker daemon...\n');
+      try {
+        execSync('sudo systemctl start docker', { stdio: 'inherit' });
+        
+        // Wait briefly and check
+        await new Promise(r => setTimeout(r, 2000));
+        if (checkDockerRunning()) {
+          console.log('✅ Docker is now running!\n');
+          return true;
+        }
+      } catch {}
+      
+      console.log('💡 Please start Docker manually and run the command again.\n');
+      process.exit(1);
+    }
+  }
+  
+  return true;
+}
+
+async function startDatabase(projectDir) {
+  const dockerComposePath = path.join(projectDir, 'docker-compose.yml');
+  
+  if (!await fs.pathExists(dockerComposePath)) {
+    console.log('⚠️  No docker-compose.yml found, skipping database setup.\n');
+    return false;
+  }
+  
+  console.log('🐳 Starting database with Docker Compose...\n');
+  
+  try {
+    // Check if containers are already running
+    const psOutput = execSync('docker compose ps -q', { 
+      cwd: projectDir,
+      stdio: 'pipe',
+      encoding: 'utf8'
+    }).trim();
+    
+    if (psOutput) {
+      console.log('✅ Database containers already running\n');
+      return true;
+    }
+  } catch {
+    // Containers not running, proceed to start
+  }
+  
+  try {
+    execSync('docker compose up -d', { 
+      cwd: projectDir,
+      stdio: 'inherit'
+    });
+    
+    console.log('\n⏳ Waiting for database to be ready...');
+    
+    // Wait for database to be ready
+    let retries = 30;
+    while (retries > 0) {
+      try {
+        execSync('docker compose exec -T db pg_isready -U postgres', { 
+          cwd: projectDir,
+          stdio: 'pipe'
+        });
+        console.log('✅ Database is ready!\n');
+        return true;
+      } catch {
+        process.stdout.write('.');
+        await new Promise(r => setTimeout(r, 1000));
+        retries--;
+      }
+    }
+    
+    console.log('\n⚠️  Database may not be ready yet. Check logs: docker compose logs\n');
+    return true;
+  } catch (error) {
+    console.log('\n❌ Failed to start database. Check Docker logs.\n');
+    return false;
+  }
+}
+
 program
   .name('launchbase')
-  .description('🚀 Generate production-ready NestJS backends with authentication, multi-tenancy, billing, and deployment')
+  .description('�� Generate production-ready NestJS backends with authentication, multi-tenancy, billing, and deployment')
   .version(VERSION);
 
-// Default command: create
+// New command - one command to create and start everything
+program
+  .command('new')
+  .description('🚀 Create new project and start development (one command experience)')
+  .argument('<appName>', 'Project name')
+  .option('-t, --template', 'Include frontend React template')
+  .option('-s, --sdk', 'Include TypeScript SDK')
+  .option('--no-docker', 'Skip Docker/database setup')
+  .option('--no-cicd', 'Skip CI/CD workflow')
+  .action(async (appName, options) => {
+    console.log('\n🚀 LaunchBase CLI v' + VERSION + '\n');
+    console.log('📁 Creating project:', appName);
+    
+    const templateDir = path.resolve(__dirname, '..', 'template');
+    const targetDir = path.resolve(process.cwd(), appName);
+
+    // Check if directory exists
+    if (await fs.pathExists(targetDir)) {
+      console.error(`❌ Target directory already exists: ${targetDir}`);
+      console.log('   Use a different name or remove the existing directory.');
+      process.exit(1);
+    }
+
+    // Copy template files with filtering
+    await fs.copy(templateDir, targetDir, {
+      filter: (src) => {
+        const relativePath = path.relative(templateDir, src);
+        
+        // Skip node_modules, dist, etc.
+        if (relativePath.includes('node_modules') || relativePath.includes('dist') || relativePath.includes('.next')) {
+          return false;
+        }
+        
+        // Skip frontend if not requested
+        if (relativePath.startsWith('frontend') && !options.template) {
+          return false;
+        }
+        
+        // Skip SDK if not requested
+        if (relativePath.startsWith('sdk') && !options.sdk) {
+          return false;
+        }
+        
+        // Skip Docker files if not requested
+        if (options.noDocker) {
+          if (relativePath.includes('Dockerfile') || 
+              relativePath.includes('docker-compose') || 
+              relativePath.includes('nginx.conf') ||
+              relativePath.includes('certbot')) {
+            return false;
+          }
+        }
+        
+        // Skip CI/CD if not requested
+        if (options.noCicd && relativePath.startsWith('.github')) {
+          return false;
+        }
+        
+        return true;
+      }
+    });
+
+    // Replace placeholders
+    const replacements = {
+      '__APP_NAME__': appName,
+      '"name": "launchbase-template"': `"name": "${appName}"`,
+    };
+
+    const filesToReplace = ['package.json', '.env.example', 'README.md'];
+    for (const rel of filesToReplace) {
+      const fp = path.join(targetDir, rel);
+      if (await fs.pathExists(fp)) {
+        replaceInFile(fp, replacements);
+      }
+    }
+
+    // Generate .env with secrets
+    const envExamplePath = path.join(targetDir, '.env.example');
+    const envPath = path.join(targetDir, '.env');
+
+    if (await fs.pathExists(envExamplePath)) {
+      let env = await fs.readFile(envExamplePath, 'utf8');
+      env = env.replace('JWT_ACCESS_SECRET=__CHANGE_ME__', `JWT_ACCESS_SECRET=${randomSecret(32)}`);
+      env = env.replace('JWT_REFRESH_SECRET=__CHANGE_ME__', `JWT_REFRESH_SECRET=${randomSecret(32)}`);
+      await fs.writeFile(envPath, env, 'utf8');
+    }
+
+    console.log('✅ Project files created\n');
+
+    // Install dependencies
+    console.log('📦 Installing dependencies...\n');
+    runCommand('npm install', { cwd: targetDir });
+    
+    if (options.template) {
+      const frontendPath = path.join(targetDir, 'frontend');
+      if (await fs.pathExists(frontendPath)) {
+        console.log('\n📦 Installing frontend dependencies...\n');
+        runCommand('npm install', { cwd: frontendPath });
+      }
+    }
+
+    // Setup Docker and database
+    if (!options.noDocker) {
+      console.log('\n🐳 Setting up database...\n');
+      
+      if (await ensureDocker()) {
+        if (await startDatabase(targetDir)) {
+          // Wait a moment for DB to be fully ready
+          await new Promise(r => setTimeout(r, 2000));
+          
+          // Run migrations
+          console.log('📄 Running database migrations...\n');
+          runCommand('npx prisma migrate dev --name init', { cwd: targetDir });
+        }
+      }
+    }
+
+    // Start dev server
+    console.log('\n🚀 Starting development server...\n');
+    console.log('━'.repeat(50));
+    console.log('  API:     http://localhost:3000');
+    console.log('  Docs:    http://localhost:3000/docs');
+    console.log('  Health:  http://localhost:3000/health');
+    if (options.template) {
+      console.log('  Frontend: http://localhost:5173');
+    }
+    console.log('━'.repeat(50));
+    console.log('\nPress Ctrl+C to stop\n');
+    
+    // Start backend
+    const backend = spawn('npm', ['run', 'start:dev'], { 
+      cwd: targetDir, 
+      stdio: 'inherit',
+      shell: true 
+    });
+    
+    // Start frontend after delay if included
+    if (options.template) {
+      const frontendPath = path.join(targetDir, 'frontend');
+      if (await fs.pathExists(frontendPath)) {
+        setTimeout(() => {
+          const frontend = spawn('npm', ['run', 'dev'], { 
+            cwd: frontendPath, 
+            stdio: 'inherit',
+            shell: true 
+          });
+        }, 5000);
+      }
+    }
+    
+    // Handle shutdown
+    process.on('SIGINT', () => {
+      console.log('\n\n👋 Shutting down...');
+      backend.kill();
+      process.exit(0);
+    });
+  });
+
+// Default command: create (scaffold only)
 program
   .argument('[appName]', 'Destination folder name', 'my-app')
   .option('-t, --template', 'Include frontend React template')
@@ -173,7 +592,7 @@ program
     console.log('\n');
   });
 
-// Dev command - one command to run everything
+// Dev command - start development environment (for existing projects)
 program
   .command('dev')
   .description('🚀 Start development environment (backend + frontend + db)')
@@ -184,16 +603,13 @@ program
     console.log('\n🚀 LaunchBase Dev\n');
     
     const projectDir = process.cwd();
-    const { spawn } = require('child_process');
     
     // Check if this is a LaunchBase project
     const packageJsonPath = path.join(projectDir, 'package.json');
     if (!await fs.pathExists(packageJsonPath)) {
       console.error('❌ No package.json found. Run this command from your project directory.');
       console.log('\n💡 Create a new project first:');
-      console.log('   npx launchbase my-app');
-      console.log('   cd my-app');
-      console.log('   npx launchbase dev\n');
+      console.log('   npx launchbase new my-app\n');
       process.exit(1);
     }
 
@@ -216,16 +632,18 @@ program
 
     // Setup database if not skipped
     if (!options.skipDb && !options.frontendOnly) {
-      console.log('🗄️  Setting up database...\n');
+      console.log('� Setting up database...\n');
       
-      // Generate Prisma client
-      runCommand('npx prisma generate', { cwd: projectDir, stdio: 'pipe' });
-      
-      // Push schema to database
-      const dbResult = runCommand('npx prisma db push --accept-data-loss', { cwd: projectDir, stdio: 'pipe' });
-      
-      if (dbResult !== null) {
-        console.log('✅ Database ready\n');
+      // Ensure Docker is available
+      if (await ensureDocker()) {
+        if (await startDatabase(projectDir)) {
+          // Generate Prisma client
+          runCommand('npx prisma generate', { cwd: projectDir });
+          
+          // Run migrations
+          console.log('\n📄 Running migrations...\n');
+          runCommand('npx prisma migrate dev', { cwd: projectDir });
+        }
       }
     }
 
@@ -234,7 +652,7 @@ program
 
     if (!options.frontendOnly) {
       // Start backend
-      console.log('🔧 Starting backend on http://localhost:3000');
+      console.log('\n🔧 Starting backend on http://localhost:3000');
       const backend = spawn('npm', ['run', 'start:dev'], { 
         cwd: projectDir, 
         stdio: 'inherit',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "launchbase",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Generate production-ready NestJS backends with authentication, multi-tenancy, billing, and deployment in minutes",
   "author": "LaunchBase",
   "keywords": [

package/template/package.json

@@ -4,7 +4,7 @@
   "private": true,
   "license": "UNLICENSED",
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "prisma generate && tsc -p tsconfig.build.json",
     "start": "node dist/src/main.js",
     "start:dev": "ts-node-dev --respawn --transpile-only src/main.ts",
     "prisma:generate": "prisma generate",

package/template/src/launchbase/launchbase.service.ts

@@ -4,7 +4,7 @@ import LaunchBase from '@launchbasex/sdk'
 
 @Injectable()
 export class LaunchBaseService implements OnModuleInit {
-  private client: LaunchBase
+  private client!: LaunchBase  // Definite assignment assertion - initialized in onModuleInit
 
   constructor(private configService: ConfigService) {}