create-solostack 1.0.0

package/src/index.js

@@ -0,0 +1,374 @@
+import { program } from 'commander';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import path from 'path';
+import { validateProjectName } from './utils/validate.js';
+import { printSuccess, printError } from './utils/logger.js';
+import { ensureDir } from './utils/files.js';
+import { installPackages } from './utils/packages.js';
+import { initGit } from './utils/git.js';
+import { generateBase } from './generators/base.js';
+import { generateDatabase } from './generators/database.js';
+import { generateAuth } from './generators/auth.js';
+import { generatePayments } from './generators/payments.js';
+import { generateEmails } from './generators/emails.js';
+import { generateUI } from './generators/ui.js';
+import {
+    AUTH_PROVIDERS,
+    DATABASES,
+    PAYMENT_PROVIDERS,
+    EMAIL_PROVIDERS,
+} from './constants.js';
+
+/**
+ * Main CLI function - orchestrates the entire project generation
+ */
+export async function main() {
+    // Display banner
+    console.log(chalk.cyan(`
+   ____        _       ____  _             _    
+  / ___|  ___ | | ___ / ___|| |_ __ _  ___| | __
+  \\___ \\ / _ \\| |/ _ \\\\___ \\| __/ _\` |/ __| |/ /
+   ___) | (_) | | (_) |___) | || (_| | (__|   < 
+  |____/ \\___/|_|\\___/|____/ \\__\\__,_|\\___|_|\\_\\
+  
+  The complete SaaS boilerplate for indie hackers
+  `));
+
+    // Parse command line arguments
+    program
+        .name('create-solostack')
+        .description('Generate a production-ready Next.js SaaS boilerplate')
+        .argument('[project-name]', 'Name of your project')
+        .parse();
+
+    let projectName = program.args[0];
+
+    // If no project name provided, ask for it
+    if (!projectName) {
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'projectName',
+                message: 'Project name:',
+                default: 'my-saas-app',
+                validate: validateProjectName,
+            },
+        ]);
+        projectName = answers.projectName;
+    } else {
+        const validation = validateProjectName(projectName);
+        if (validation !== true) {
+            printError(validation);
+            process.exit(1);
+        }
+    }
+
+    // Ask configuration questions
+    const config = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'auth',
+            message: 'Choose authentication:',
+            choices: AUTH_PROVIDERS,
+            default: AUTH_PROVIDERS[0],
+        },
+        {
+            type: 'list',
+            name: 'database',
+            message: 'Choose database:',
+            choices: DATABASES,
+            default: DATABASES[0],
+        },
+        {
+            type: 'list',
+            name: 'payments',
+            message: 'Choose payment provider:',
+            choices: PAYMENT_PROVIDERS,
+            default: PAYMENT_PROVIDERS[0],
+        },
+        {
+            type: 'list',
+            name: 'email',
+            message: 'Choose email provider:',
+            choices: EMAIL_PROVIDERS,
+            default: EMAIL_PROVIDERS[0],
+        },
+        {
+            type: 'confirm',
+            name: 'includeUI',
+            message: 'Include shadcn/ui components?',
+            default: true,
+        },
+        {
+            type: 'confirm',
+            name: 'initGit',
+            message: 'Initialize git repository?',
+            default: true,
+        },
+    ]);
+
+    const projectPath = path.join(process.cwd(), projectName);
+
+    try {
+        // Start generation
+        console.log(chalk.cyan('\\n⚙️  Creating your SaaS boilerplate...\\n'));
+
+        // Ensure project directory exists
+        await ensureDir(projectPath);
+
+        // Generate base Next.js project
+        let spinner = ora('Generating Next.js project').start();
+        await generateBase(projectPath, projectName, config);
+        spinner.succeed('Generated Next.js project');
+
+        // Generate database integration
+        spinner = ora('Configuring database').start();
+        await generateDatabase(projectPath, config.database);
+        spinner.succeed('Configured database (Prisma + PostgreSQL)');
+
+        // Generate authentication
+        spinner = ora('Configuring authentication').start();
+        await generateAuth(projectPath, config.auth);
+        spinner.succeed('Configured authentication (NextAuth.js)');
+
+        // Generate payments
+        spinner = ora('Configuring payments').start();
+        await generatePayments(projectPath, config.payments);
+        spinner.succeed('Configured payments (Stripe)');
+
+        // Generate emails
+        spinner = ora('Configuring emails').start();
+        await generateEmails(projectPath, config.email);
+        spinner.succeed('Configured emails (Resend)');
+
+        // Generate UI components
+        if (config.includeUI) {
+            spinner = ora('Adding UI components').start();
+            await generateUI(projectPath);
+            spinner.succeed('Added UI components (shadcn/ui)');
+        }
+
+        // Install dependencies
+        spinner = ora('Installing dependencies (this may take a minute...)').start();
+        await installPackages(projectPath);
+        spinner.succeed('Installed dependencies');
+
+        // Initialize git
+        if (config.initGit) {
+            spinner = ora('Initializing git repository').start();
+            await initGit(projectPath);
+            spinner.succeed('Initialized git repository');
+        }
+
+        // Success message
+        printSuccess(projectName, projectPath);
+
+        // Optional setup wizard
+        console.log(); // Empty line for spacing
+        const { setupNow } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'setupNow',
+                message: 'Would you like to set up your API keys now?',
+                default: true,
+            },
+        ]);
+
+        if (setupNow) {
+            await runSetupWizard(projectPath);
+        } else {
+            console.log(chalk.yellow('\nℹ️  You can set up your API keys later by:'));
+            console.log(chalk.white('  1. Copy .env.example to .env'));
+            console.log(chalk.white('  2. Add your API keys to .env'));
+            console.log(chalk.white('  3. Run: npm run dev\n'));
+        }
+    } catch (error) {
+        printError(error.message);
+        console.error(error);
+        process.exit(1);
+    }
+}
+
+/**
+ * Interactive setup wizard for API keys
+ */
+async function runSetupWizard(projectPath) {
+    console.log(chalk.cyan('\n🔑 API Key Setup'));
+    console.log(chalk.gray("Let's configure your environment variables.\n"));
+
+    const crypto = await import('crypto');
+
+    // Database setup
+    console.log(chalk.cyan('📍 Database'));
+    const { databaseUrl } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'databaseUrl',
+            message: 'PostgreSQL connection string:',
+            default: 'postgresql://user:password@localhost:5432/dbname',
+            validate: (input) => {
+                if (!input) return 'Database URL is required';
+                if (!input.startsWith('postgres')) return 'Must be a PostgreSQL connection string';
+                return true;
+            },
+        },
+    ]);
+    console.log(chalk.gray('💡 Get from: Neon (neon.tech) or Supabase (supabase.com)\n'));
+
+    // NextAuth setup
+    console.log(chalk.cyan('📍 NextAuth'));
+    const { nextauthSecret, nextauthUrl } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'nextauthSecret',
+            message: 'NEXTAUTH_SECRET (press Enter to auto-generate):',
+            default: () => crypto.randomBytes(32).toString('base64'),
+        },
+        {
+            type: 'input',
+            name: 'nextauthUrl',
+            message: 'NEXTAUTH_URL:',
+            default: 'http://localhost:3000',
+        },
+    ]);
+    console.log(chalk.gray('💡 Generated secure secret automatically\n'));
+
+    // Stripe setup
+    console.log(chalk.cyan('📍 Stripe'));
+    const { stripeSecretKey, stripePublishableKey, stripeProPrice, stripeEnterprisePrice } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'stripeSecretKey',
+            message: 'Stripe Secret Key (sk_test_...):',
+            validate: (input) => {
+                if (!input) return 'Stripe Secret Key is required';
+                if (!input.startsWith('sk_')) return 'Must start with sk_test_ or sk_live_';
+                return true;
+            },
+        },
+        {
+            type: 'input',
+            name: 'stripePublishableKey',
+            message: 'Stripe Publishable Key (pk_test_...):',
+            validate: (input) => {
+                if (!input) return 'Stripe Publishable Key is required';
+                if (!input.startsWith('pk_')) return 'Must start with pk_test_ or pk_live_';
+                return true;
+            },
+        },
+        {
+            type: 'input',
+            name: 'stripeProPrice',
+            message: 'Pro Plan Price ID (price_...):',
+            default: 'price_pro',
+            validate: (input) => input ? true : 'Price ID is required',
+        },
+        {
+            type: 'input',
+            name: 'stripeEnterprisePrice',
+            message: 'Enterprise Plan Price ID (price_...):',
+            default: 'price_enterprise',
+            validate: (input) => input ? true : 'Price ID is required',
+        },
+    ]);
+    console.log(chalk.gray('💡 Get from: dashboard.stripe.com/test/products\n'));
+
+    // Resend setup
+    console.log(chalk.cyan('📍 Resend'));
+    const { resendApiKey, fromEmail } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'resendApiKey',
+            message: 'Resend API Key (re_...):',
+            validate: (input) => {
+                if (!input) return 'Resend API Key is required';
+                if (!input.startsWith('re_')) return 'Must start with re_';
+                return true;
+            },
+        },
+        {
+            type: 'input',
+            name: 'fromEmail',
+            message: 'From Email (optional):',
+            default: 'onboarding@resend.dev',
+        },
+    ]);
+    console.log(chalk.gray('💡 Get from: resend.com/api-keys\n'));
+
+    // OAuth setup (optional)
+    console.log(chalk.cyan('📍 OAuth (Optional - press Enter to skip)'));
+    const { googleClientId, googleClientSecret, githubClientId, githubClientSecret } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'googleClientId',
+            message: 'Google Client ID (optional):',
+            default: '',
+        },
+        {
+            type: 'input',
+            name: 'googleClientSecret',
+            message: 'Google Client Secret (optional):',
+            default: '',
+        },
+        {
+            type: 'input',
+            name: 'githubClientId',
+            message: 'GitHub Client ID (optional):',
+            default: '',
+        },
+        {
+            type: 'input',
+            name: 'githubClientSecret',
+            message: 'GitHub Client Secret (optional):',
+            default: '',
+        },
+    ]);
+    console.log(chalk.gray('💡 Google: console.cloud.google.com/apis/credentials'));
+    console.log(chalk.gray('💡 GitHub: github.com/settings/developers\n'));
+
+    // Write to .env file
+    const fs = await import('fs-extra');
+    const envPath = path.join(projectPath, '.env');
+
+    const envContent = `# Database
+DATABASE_URL="${databaseUrl}"
+
+# NextAuth
+NEXTAUTH_SECRET="${nextauthSecret}"
+NEXTAUTH_URL="${nextauthUrl}"
+
+# Stripe
+STRIPE_SECRET_KEY="${stripeSecretKey}"
+STRIPE_WEBHOOK_SECRET="whsec_..." # Get this from Stripe webhook settings
+NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY="${stripePublishableKey}"
+STRIPE_PRO_PRICE_ID="${stripeProPrice}"
+STRIPE_ENTERPRISE_PRICE_ID="${stripeEnterprisePrice}"
+
+# Resend
+RESEND_API_KEY="${resendApiKey}"
+FROM_EMAIL="${fromEmail}"
+
+# OAuth Providers${googleClientId ? `
+GOOGLE_CLIENT_ID="${googleClientId}"
+GOOGLE_CLIENT_SECRET="${googleClientSecret}"` : `
+# GOOGLE_CLIENT_ID=""
+# GOOGLE_CLIENT_SECRET=""`}${githubClientId ? `
+GITHUB_CLIENT_ID="${githubClientId}"
+GITHUB_CLIENT_SECRET="${githubClientSecret}"` : `
+# GITHUB_CLIENT_ID=""
+# GITHUB_CLIENT_SECRET=""`}
+`;
+
+    await fs.writeFile(envPath, envContent);
+
+    console.log(chalk.green('✅ Environment configured!'));
+    console.log(chalk.green('✅ Wrote to .env file\n'));
+
+    console.log(chalk.cyan("📝 Don't forget:"));
+    console.log(chalk.white('  1. Get your Stripe Webhook Secret from Stripe Dashboard'));
+    console.log(chalk.white('  2. Run: npm run db:push (to set up database)'));
+    console.log(chalk.white('  3. Run: npm run db:seed (to add test users)'));
+    console.log(chalk.white('  4. Run: npm run dev (to start development)\n'));
+}

package/src/utils/files.js

@@ -0,0 +1,81 @@
+import fs from 'fs-extra';
+import path from 'path';
+import ejs from 'ejs';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Ensures a directory exists, creating it if necessary
+ * @param {string} dirPath - Directory path to ensure
+ */
+export async function ensureDir(dirPath) {
+    await fs.ensureDir(dirPath);
+}
+
+/**
+ * Writes content to a file, creating parent directories if needed
+ * @param {string} filePath - File path to write to
+ * @param {string} content - Content to write
+ */
+export async function writeFile(filePath, content) {
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, content, 'utf-8');
+}
+
+/**
+ * Renders an EJS template with data
+ * @param {string} templatePath - Path to the EJS template file
+ * @param {object} data - Data to pass to the template
+ * @returns {Promise<string>} - Rendered template content
+ */
+export async function renderTemplate(templatePath, data = {}) {
+    const templateContent = await fs.readFile(templatePath, 'utf-8');
+    return ejs.render(templateContent, data);
+}
+
+/**
+ * Renders an EJS template and writes it to a file
+ * @param {string} templatePath - Path to the EJS template file
+ * @param {string} outputPath - Path where the rendered file should be written
+ * @param {object} data - Data to pass to the template
+ */
+export async function renderTemplateToFile(templatePath, outputPath, data = {}) {
+    const content = await renderTemplate(templatePath, data);
+    await writeFile(outputPath, content);
+}
+
+/**
+ * Copies a file or directory
+ * @param {string} source - Source path
+ * @param {string} destination - Destination path
+ */
+export async function copy(source, destination) {
+    await fs.copy(source, destination);
+}
+
+/**
+ * Gets the path to a template file
+ * @param {string} relativePath - Relative path within templates directory
+ * @returns {string} - Absolute path to template
+ */
+export function getTemplatePath(relativePath) {
+    // Go up from utils -> src -> root, then into src/templates
+    return path.join(__dirname, '..', 'templates', relativePath);
+}
+
+/**
+ * Checks if a file or directory exists
+ * @param {string} filePath - Path to check
+ * @returns {Promise<boolean>} - True if exists
+ */
+export async function exists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    } catch {
+        return false;
+    }
+}

package/src/utils/git.js

@@ -0,0 +1,69 @@
+import { execa } from 'execa';
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * Initializes a git repository in the specified directory
+ * @param {string} projectPath - Path to the project directory
+ * @returns {Promise<void>}
+ */
+export async function initGit(projectPath) {
+    try {
+        // Check if git is available
+        await execa('git', ['--version']);
+    } catch {
+        throw new Error('Git is not installed. Please install git to use this feature.');
+    }
+
+    // Initialize git repository
+    await execa('git', ['init'], { cwd: projectPath });
+
+    // Create .gitignore if it doesn't exist
+    const gitignorePath = path.join(projectPath, '.gitignore');
+    if (!await fs.pathExists(gitignorePath)) {
+        const gitignoreContent = `# dependencies
+node_modules
+.pnp
+.pnp.js
+
+# testing
+coverage
+
+# next.js
+.next/
+out/
+build
+dist
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# local env files
+.env
+.env*.local
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts
+
+# prisma
+prisma/migrations/
+`;
+        await fs.writeFile(gitignorePath, gitignoreContent, 'utf-8');
+    }
+
+    // Stage all files
+    await execa('git', ['add', '-A'], { cwd: projectPath });
+
+    // Create initial commit
+    await execa('git', ['commit', '-m', 'Initial commit from create-solostack'], { cwd: projectPath });
+}

package/src/utils/logger.js

@@ -0,0 +1,62 @@
+import chalk from 'chalk';
+
+/**
+ * Prints a success message with next steps after project generation
+ * @param {string} projectName - Name of the generated project
+ * @param {string} projectPath - Absolute path to the project
+ */
+export function printSuccess(projectName, projectPath) {
+    console.log(chalk.green('\n✅ Success! Your SaaS boilerplate is ready.\n'));
+
+    console.log(chalk.cyan('📁 Project created at:'));
+    console.log(chalk.white(`   ${projectPath}\n`));
+
+    console.log(chalk.cyan('🚀 Next steps:\n'));
+    console.log(chalk.white(`   cd ${projectName}`));
+    console.log(chalk.white('   cp .env.example .env'));
+    console.log(chalk.white('   # Add your environment variables to .env\n'));
+
+    console.log(chalk.cyan('🗄️  Database setup:\n'));
+    console.log(chalk.white('   npm run db:push     # Push schema to database'));
+    console.log(chalk.white('   npm run db:seed     # Seed with sample data\n'));
+
+    console.log(chalk.cyan('⚡ Start development:\n'));
+    console.log(chalk.white('   npm run dev\n'));
+
+    console.log(chalk.cyan('📚 Documentation:\n'));
+    console.log(chalk.white('   - NextAuth: https://next-auth.js.org'));
+    console.log(chalk.white('   - Prisma: https://prisma.io'));
+    console.log(chalk.white('   - Stripe: https://stripe.com/docs'));
+    console.log(chalk.white('   - Resend: https://resend.com/docs\n'));
+
+    console.log(chalk.yellow('⚠️  Remember to:'));
+    console.log(chalk.white('   - Set up a PostgreSQL database'));
+    console.log(chalk.white('   - Get API keys for Stripe and Resend'));
+    console.log(chalk.white('   - Configure OAuth providers (optional)\n'));
+
+    console.log(chalk.magenta('💡 Happy building! 🚀\n'));
+}
+
+/**
+ * Prints an error message in red
+ * @param {string} message - Error message to display
+ */
+export function printError(message) {
+    console.error(chalk.red(`\n❌ Error: ${message}\n`));
+}
+
+/**
+ * Prints a warning message in yellow
+ * @param {string} message - Warning message to display
+ */
+export function printWarning(message) {
+    console.warn(chalk.yellow(`\n⚠️  Warning: ${message}\n`));
+}
+
+/**
+ * Prints an info message in blue
+ * @param {string} message - Info message to display
+ */
+export function printInfo(message) {
+    console.log(chalk.blue(`\nℹ️  ${message}\n`));
+}

package/src/utils/packages.js

@@ -0,0 +1,75 @@
+import { execa } from 'execa';
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * Detects which package manager is available
+ * Priority: pnpm > yarn > npm
+ * @returns {Promise<{name: string, command: string}>} - Package manager info
+ */
+export async function detectPackageManager() {
+    try {
+        await execa('pnpm', ['--version']);
+        return { name: 'pnpm', command: 'pnpm' };
+    } catch {
+        try {
+            await execa('yarn', ['--version']);
+            return { name: 'yarn', command: 'yarn' };
+        } catch {
+            return { name: 'npm', command: 'npm' };
+        }
+    }
+}
+
+/**
+ * Installs npm packages in the specified directory
+ * @param {string} projectPath - Path to the project directory
+ * @returns {Promise<void>}
+ */
+export async function installPackages(projectPath) {
+    const pm = await detectPackageManager();
+
+    // Check if package.json exists
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    if (!await fs.pathExists(packageJsonPath)) {
+        throw new Error('package.json not found in project directory');
+    }
+
+    // Install dependencies
+    const installCommand = pm.name === 'yarn' ? 'install' : 'install';
+
+    await execa(pm.command, [installCommand], {
+        cwd: projectPath,
+        stdio: 'inherit',
+    });
+}
+
+/**
+ * Adds a package to the project
+ * @param {string} projectPath - Path to the project directory
+ * @param {string|string[]} packages - Package name(s) to add
+ * @param {object} options - Options
+ * @param {boolean} options.dev - Install as dev dependency
+ */
+export async function addPackage(projectPath, packages, options = {}) {
+    const pm = await detectPackageManager();
+    const pkgArray = Array.isArray(packages) ? packages : [packages];
+
+    let args = [];
+
+    if (pm.name === 'npm') {
+        args = ['install', ...pkgArray];
+        if (options.dev) args.push('--save-dev');
+    } else if (pm.name === 'yarn') {
+        args = ['add', ...pkgArray];
+        if (options.dev) args.push('--dev');
+    } else if (pm.name === 'pnpm') {
+        args = ['add', ...pkgArray];
+        if (options.dev) args.push('--save-dev');
+    }
+
+    await execa(pm.command, args, {
+        cwd: projectPath,
+        stdio: 'inherit',
+    });
+}

package/src/utils/validate.js

@@ -0,0 +1,17 @@
+import validateNpmPackageName from 'validate-npm-package-name';
+
+/**
+ * Validates a project name for npm package compatibility
+ * @param {string} name - The project name to validate
+ * @returns {boolean|string} - True if valid, error message if invalid
+ */
+export function validateProjectName(name) {
+    const validation = validateNpmPackageName(name);
+
+    if (!validation.validForNewPackages) {
+        const error = validation.errors?.[0] || validation.warnings?.[0] || 'Unknown error';
+        return `Invalid project name: ${error}`;
+    }
+
+    return true;
+}