projects-init-cli 1.1.0

package/README.md

@@ -0,0 +1,127 @@
+# Projects Init CLI
+
+A powerful CLI tool to initialize monorepo projects with customizable frontend, backend, and storage options.
+
+## Features
+
+### Frontend Options
+
+- **Next.js** - React framework with Tailwind CSS
+- **React** - React with Vite and Tailwind CSS
+- **HTML** - Plain HTML with Tailwind CSS and Vite
+
+### Backend Options
+
+- **Express.js** - Node.js web framework
+- **NestJS** - Progressive Node.js framework
+- **FastAPI** - Modern Python web framework
+- **AWS CDK** - Infrastructure as code
+- **AWS SAM** - Serverless Application Model
+
+### Storage Options
+
+- **CDK Database** - Create database using AWS CDK
+- **Local SQLite** - SQLite database for local development
+- **External Database URL** - Connect to existing database
+
+### Database Types
+
+- **SQL**: Raw SQL or Prisma ORM
+- **NoSQL**: DynamoDB or MongoDB
+
+### API Types (for Express/NestJS)
+
+- **REST API**
+- **GraphQL**
+
+## Installation
+
+### Global Installation
+
+```bash
+npm install -g projects-init-cli
+```
+
+### Local Installation
+
+```bash
+npm install
+npm run build
+npm link
+```
+
+### Use with npx (No Installation Required)
+
+```bash
+npx projects-init-cli
+```
+
+## Usage
+
+Run the CLI tool:
+
+```bash
+projects-init
+```
+
+The tool will guide you through interactive prompts to select:
+
+1. Project name
+2. Frontend framework
+3. Backend framework
+4. Storage option
+5. Database type (if applicable)
+6. Database options (SQL/NoSQL, ORM, etc.)
+7. API type (for Express/NestJS)
+
+## Example
+
+```bash
+$ projects-init
+
+🚀 Project Initializer CLI
+
+? What is your project name? my-awesome-app
+? Select frontend framework: Next.js (with Tailwind)
+? Select backend framework: Express.js
+? Select storage option: Local SQLite (Node.js)
+? Select database type: SQL
+? Select SQL option: Prisma ORM
+? Select API type: REST API
+
+✅ Project created successfully!
+
+Next steps:
+  cd my-awesome-app
+  npm install
+  npm run dev
+```
+
+## Project Structure
+
+Generated projects follow a monorepo structure:
+
+```
+my-project/
+├── frontend/          # Frontend application
+├── backend/           # Backend application
+├── package.json       # Root package.json with workspaces
+└── README.md          # Project documentation
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build the project
+npm run build
+
+# Run in development mode
+npm run dev
+```
+
+## License
+
+MIT

package/dist/generator.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateProject = generateProject;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const templates_1 = require("./templates");
+async function generateProject(config) {
+    const projectPath = path_1.default.resolve(process.cwd(), config.projectName);
+    // Check if directory exists
+    if (await fs_extra_1.default.pathExists(projectPath)) {
+        throw new Error(`Directory ${config.projectName} already exists`);
+    }
+    console.log(chalk_1.default.blue(`\n📁 Creating project structure...`));
+    await fs_extra_1.default.ensureDir(projectPath);
+    // Generate monorepo structure
+    await (0, templates_1.generateMonorepoConfig)(projectPath, config);
+    // Generate frontend
+    console.log(chalk_1.default.blue(`\n🎨 Generating frontend (${config.frontend})...`));
+    await (0, templates_1.generateFrontend)(projectPath, config);
+    // Generate backend
+    console.log(chalk_1.default.blue(`\n⚙️  Generating backend (${config.backend})...`));
+    await (0, templates_1.generateBackend)(projectPath, config);
+    // Generate root files
+    console.log(chalk_1.default.blue(`\n📄 Generating root configuration files...`));
+    await (0, templates_1.generateRootFiles)(projectPath, config);
+    // Initialize git repository
+    console.log(chalk_1.default.blue(`\n🔧 Initializing git repository...`));
+    await initializeGit(projectPath);
+    console.log(chalk_1.default.green(`\n✨ Project structure created at: ${projectPath}`));
+}
+async function initializeGit(projectPath) {
+    const { execSync } = require('child_process');
+    try {
+        // Initialize git repository
+        execSync('git init', { cwd: projectPath, stdio: 'pipe' });
+        // Create initial commit
+        execSync('git add .', { cwd: projectPath, stdio: 'pipe' });
+        execSync('git commit -m "Initial commit"', {
+            cwd: projectPath,
+            stdio: 'pipe',
+            env: { ...process.env, GIT_AUTHOR_NAME: 'Projects Init CLI', GIT_AUTHOR_EMAIL: 'cli@projects-init.dev' }
+        });
+        console.log(chalk_1.default.green('✓ Git repository initialized with initial commit'));
+    }
+    catch (error) {
+        // Git might not be installed or there might be an issue, but don't fail the whole process
+        if (error.message && error.message.includes('not a git repository')) {
+            // Already initialized or other git issue
+            console.log(chalk_1.default.yellow('⚠️  Git initialization skipped'));
+        }
+        else {
+            console.log(chalk_1.default.yellow('⚠️  Git initialization skipped (git may not be installed)'));
+        }
+    }
+}

package/dist/index.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = require("./prompts");
+const generator_1 = require("./generator");
+const program = new commander_1.Command();
+program
+    .name('projects-init')
+    .description('CLI tool to initialize projects with customizable tech stacks')
+    .version('1.0.0')
+    .action(async () => {
+    try {
+        console.log(chalk_1.default.blue.bold('\n🚀 Project Initializer CLI\n'));
+        const answers = await (0, prompts_1.promptUser)();
+        await (0, generator_1.generateProject)(answers);
+        console.log(chalk_1.default.green.bold('\n✅ Project created successfully!'));
+        console.log(chalk_1.default.yellow('\nNext steps:'));
+        console.log(chalk_1.default.white(`  cd ${answers.projectName}`));
+        console.log(chalk_1.default.white('  npm install'));
+        console.log(chalk_1.default.white('  npm run dev'));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red.bold('\n❌ Error:'), error);
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/prompts.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptUser = promptUser;
+const inquirer_1 = __importDefault(require("inquirer"));
+async function promptUser() {
+    const answers = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'projectName',
+            message: 'What is your project name?',
+            default: 'my-project',
+            validate: (input) => {
+                if (!input.trim()) {
+                    return 'Project name cannot be empty';
+                }
+                if (!/^[a-z0-9-]+$/.test(input)) {
+                    return 'Project name can only contain lowercase letters, numbers, and hyphens';
+                }
+                return true;
+            }
+        },
+        {
+            type: 'list',
+            name: 'frontend',
+            message: 'Select frontend framework:',
+            choices: [
+                { name: 'Next.js (with Tailwind)', value: 'nextjs' },
+                { name: 'React (with Tailwind)', value: 'react' },
+                { name: 'HTML (with Tailwind)', value: 'html' }
+            ]
+        },
+        {
+            type: 'list',
+            name: 'backend',
+            message: 'Select backend framework:',
+            choices: [
+                { name: 'Express.js', value: 'express' },
+                { name: 'NestJS', value: 'nest' },
+                { name: 'FastAPI (Python)', value: 'fastapi' },
+                { name: 'AWS CDK Deployment', value: 'cdk' },
+                { name: 'AWS SAM Deployment', value: 'sam' }
+            ]
+        },
+        {
+            type: 'list',
+            name: 'storage',
+            message: 'Select storage option:',
+            choices: [
+                { name: 'CDK to create database', value: 'cdk' },
+                { name: 'Local SQLite (Node.js)', value: 'local-sqlite' },
+                { name: 'Local JSON file', value: 'local-json' },
+                { name: 'External database URL', value: 'external-url' }
+            ]
+        }
+    ]);
+    const config = {
+        projectName: answers.projectName,
+        frontend: answers.frontend,
+        backend: answers.backend,
+        storage: answers.storage
+    };
+    // If storage is external-url, ask for database URL
+    if (config.storage === 'external-url') {
+        const urlAnswer = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'databaseUrl',
+                message: 'Enter database connection URL:',
+                validate: (input) => {
+                    if (!input.trim()) {
+                        return 'Database URL cannot be empty';
+                    }
+                    return true;
+                }
+            }
+        ]);
+        config.databaseUrl = urlAnswer.databaseUrl;
+    }
+    // Ask for database type if backend is not CDK/SAM or storage is not CDK/local-json
+    if (config.backend !== 'cdk' && config.backend !== 'sam' && config.storage !== 'cdk' && config.storage !== 'local-json') {
+        const dbTypeAnswer = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'databaseType',
+                message: 'Select database type:',
+                choices: [
+                    { name: 'SQL', value: 'sql' },
+                    { name: 'NoSQL', value: 'nosql' }
+                ]
+            }
+        ]);
+        config.databaseType = dbTypeAnswer.databaseType;
+        if (config.databaseType === 'sql') {
+            const sqlAnswer = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'sqlOption',
+                    message: 'Select SQL option:',
+                    choices: [
+                        { name: 'Raw SQL', value: 'raw-sql' },
+                        { name: 'Prisma ORM', value: 'prisma' }
+                    ]
+                }
+            ]);
+            config.sqlOption = sqlAnswer.sqlOption;
+        }
+        else {
+            const nosqlAnswer = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'nosqlOption',
+                    message: 'Select NoSQL option:',
+                    choices: [
+                        { name: 'DynamoDB', value: 'dynamodb' },
+                        { name: 'MongoDB', value: 'mongodb' }
+                    ]
+                }
+            ]);
+            config.nosqlOption = nosqlAnswer.nosqlOption;
+        }
+    }
+    else if (config.storage === 'cdk') {
+        // For CDK storage, still ask database type
+        const dbTypeAnswer = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'databaseType',
+                message: 'Select database type for CDK:',
+                choices: [
+                    { name: 'SQL (RDS)', value: 'sql' },
+                    { name: 'NoSQL (DynamoDB)', value: 'nosql' }
+                ]
+            }
+        ]);
+        config.databaseType = dbTypeAnswer.databaseType;
+    }
+    // Ask for API type if backend is Express or NestJS
+    if (config.backend === 'express' || config.backend === 'nest') {
+        const apiAnswer = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'apiType',
+                message: 'Select API type:',
+                choices: [
+                    { name: 'REST API', value: 'rest' },
+                    { name: 'GraphQL', value: 'graphql' }
+                ]
+            }
+        ]);
+        config.apiType = apiAnswer.apiType;
+    }
+    return config;
+}

package/dist/templates/backend/cdk.js

@@ -0,0 +1,211 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCDK = generateCDK;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+async function generateCDK(backendPath, config) {
+    const appName = config.projectName.replace(/[^a-z0-9-]/gi, '-').toLowerCase();
+    const stackName = config.projectName.replace(/[^a-zA-Z0-9]/g, '');
+    const packageJson = {
+        name: `${appName}-backend`,
+        version: '0.1.0',
+        bin: {
+            [appName]: 'bin/app.js'
+        },
+        scripts: {
+            build: 'tsc',
+            watch: 'tsc -w',
+            test: 'vitest',
+            'test:ui': 'vitest --ui',
+            'test:coverage': 'vitest --coverage',
+            cdk: 'cdk'
+        },
+        dependencies: {
+            'aws-cdk-lib': '^2.169.0',
+            constructs: '^10.4.2',
+            'source-map-support': '^0.5.21'
+        },
+        devDependencies: {
+            '@types/node': '^22.7.5',
+            'aws-cdk': '^2.169.0',
+            'ts-node': '^10.9.2',
+            'typescript': '^5.6.3',
+            'vitest': '^2.1.3',
+            '@vitest/ui': '^2.1.3',
+            '@vitest/coverage-v8': '^2.1.3'
+        }
+    };
+    await fs_extra_1.default.writeJSON(path_1.default.join(backendPath, 'package.json'), packageJson, { spaces: 2 });
+    // Create cdk.json
+    const cdkJson = {
+        app: 'npx ts-node --prefer-ts-exts bin/app.ts',
+        watch: {
+            include: ['**'],
+            exclude: [
+                'README.md',
+                'cdk*.json',
+                '**/*.d.ts',
+                '**/*.js',
+                'tsconfig.json',
+                'package*.json',
+                'yarn.lock',
+                'node_modules',
+                'test'
+            ]
+        },
+        context: {
+            '@aws-cdk/aws-lambda:recognizeLayerVersion': true,
+        }
+    };
+    await fs_extra_1.default.writeJSON(path_1.default.join(backendPath, 'cdk.json'), cdkJson, { spaces: 2 });
+    // Create TypeScript config
+    const tsconfig = {
+        compilerOptions: {
+            target: 'ES2020',
+            module: 'commonjs',
+            lib: ['es2020'],
+            declaration: true,
+            strict: true,
+            noImplicitAny: true,
+            strictNullChecks: true,
+            noImplicitThis: true,
+            alwaysStrict: true,
+            noUnusedLocals: false,
+            noUnusedParameters: false,
+            noImplicitReturns: true,
+            noFallthroughCasesInSwitch: false,
+            inlineSourceMap: true,
+            inlineSources: true,
+            experimentalDecorators: true,
+            strictPropertyInitialization: false,
+            typeRoots: ['./node_modules/@types'],
+            esModuleInterop: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true
+        },
+        exclude: ['node_modules', 'cdk.out']
+    };
+    await fs_extra_1.default.writeJSON(path_1.default.join(backendPath, 'tsconfig.json'), tsconfig, { spaces: 2 });
+    // Create bin directory
+    const binPath = path_1.default.join(backendPath, 'bin');
+    await fs_extra_1.default.ensureDir(binPath);
+    const appTs = `#!/usr/bin/env node
+import 'source-map-support/register';
+import * as cdk from 'aws-cdk-lib';
+import { ${stackName}Stack } from '../lib/${stackName}-stack';
+
+const app = new cdk.App();
+new ${stackName}Stack(app, '${stackName}Stack', {
+  env: {
+    account: process.env.CDK_DEFAULT_ACCOUNT,
+    region: process.env.CDK_DEFAULT_REGION,
+  },
+});
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(binPath, 'app.ts'), appTs);
+    // Create lib directory
+    const libPath = path_1.default.join(backendPath, 'lib');
+    await fs_extra_1.default.ensureDir(libPath);
+    let stackContent = `import * as cdk from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+`;
+    if (config.databaseType === 'sql') {
+        stackContent += `import * as rds from 'aws-cdk-lib/aws-rds';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+`;
+    }
+    else if (config.databaseType === 'nosql') {
+        stackContent += `import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
+`;
+    }
+    stackContent += `
+export class ${stackName}Stack extends cdk.Stack {
+  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+`;
+    if (config.databaseType === 'sql') {
+        stackContent += `    // Create VPC for RDS
+    const vpc = new ec2.Vpc(this, 'VPC', {
+      maxAzs: 2,
+    });
+
+    // Create RDS Database
+    const database = new rds.DatabaseInstance(this, 'Database', {
+      engine: rds.DatabaseInstanceEngine.postgres({
+        version: rds.PostgresEngineVersion.VER_15_4,
+      }),
+      instanceType: ec2.InstanceType.of(
+        ec2.InstanceClass.T3,
+        ec2.InstanceSize.MICRO
+      ),
+      vpc,
+      databaseName: '${config.projectName}',
+      deletionProtection: false,
+    });
+
+    // Output database endpoint
+    new cdk.CfnOutput(this, 'DatabaseEndpoint', {
+      value: database.instanceEndpoint.hostname,
+    });
+`;
+    }
+    else if (config.databaseType === 'nosql') {
+        stackContent += `    // Create DynamoDB Table
+    const table = new dynamodb.Table(this, 'Table', {
+      partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
+      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
+    });
+
+    // Output table name
+    new cdk.CfnOutput(this, 'TableName', {
+      value: table.tableName,
+    });
+`;
+    }
+    stackContent += `  }
+}
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(libPath, `${stackName}-stack.ts`), stackContent);
+    // Create README
+    const readme = `# CDK Backend
+
+This is an AWS CDK project for deploying infrastructure.
+
+## Useful commands
+
+- \`npm run build\`   compile typescript to js
+- \`npm run watch\`   watch for changes and compile
+- \`npm run test\`    run vitest tests
+- \`npm run test:ui\` run tests with UI
+- \`npm run test:coverage\` run tests with coverage
+- \`npm run cdk deploy\`      deploy this stack to your default AWS account/region
+- \`npm run cdk diff\`        compare deployed stack with current state
+- \`npm run cdk synth\`       emits the synthesized CloudFormation template
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(backendPath, 'README.md'), readme);
+    // Create test directory with example test
+    const testPath = path_1.default.join(backendPath, 'test');
+    await fs_extra_1.default.ensureDir(testPath);
+    const testFile = `import { describe, it, expect } from 'vitest';
+import * as cdk from 'aws-cdk-lib';
+import { Template } from 'aws-cdk-lib/assertions';
+import { ${stackName}Stack } from '../lib/${stackName}-stack';
+
+describe('${stackName}Stack', () => {
+  it('has required resources', () => {
+    const app = new cdk.App();
+    const stack = new ${stackName}Stack(app, 'MyTestStack');
+    const template = Template.fromStack(stack);
+
+    // Add your test assertions here
+    // Example: template.resourceCountIs('AWS::DynamoDB::Table', 1);
+    expect(template).toBeDefined();
+  });
+});
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(testPath, `${stackName}-stack.test.ts`), testFile);
+}