projects-init-cli 2.0.0

package/dist/templates/backend/nestjs.js

@@ -0,0 +1,388 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNestJS = generateNestJS;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+async function generateNestJS(backendPath, config) {
+    const dependencies = {
+        '@nestjs/common': '^10.4.8',
+        '@nestjs/core': '^10.4.8',
+        '@nestjs/platform-express': '^10.4.8',
+        '@nestjs/testing': '^10.4.8',
+        'reflect-metadata': '^0.2.2',
+        'rxjs': '^7.8.1'
+    };
+    const devDependencies = {
+        '@nestjs/cli': '^10.4.5',
+        '@nestjs/schematics': '^10.1.1',
+        '@types/express': '^5.0.0',
+        '@types/node': '^22.7.5',
+        'source-map-support': '^0.5.21',
+        'ts-loader': '^9.5.1',
+        'ts-node': '^10.9.2',
+        'tsconfig-paths': '^4.2.0',
+        typescript: '^5.6.3'
+    };
+    // Add database dependencies
+    if (config.storage === 'local-sqlite') {
+        if (config.databaseType === 'sql' && config.sqlOption === 'prisma') {
+            dependencies['@prisma/client'] = '^6.0.1';
+            dependencies['prisma'] = '^6.0.1';
+        }
+        else if (config.databaseType === 'sql') {
+            dependencies['typeorm'] = '^0.3.20';
+            dependencies['better-sqlite3'] = '^11.7.0';
+            devDependencies['@types/better-sqlite3'] = '^7.6.9';
+        }
+        else if (config.databaseType === 'nosql' && config.nosqlOption === 'mongodb') {
+            dependencies['@nestjs/mongoose'] = '^10.1.0';
+            dependencies['mongoose'] = '^8.8.4';
+        }
+        else if (config.databaseType === 'nosql' && config.nosqlOption === 'dynamodb') {
+            dependencies['@aws-sdk/client-dynamodb'] = '^3.699.0';
+            dependencies['@aws-sdk/lib-dynamodb'] = '^3.699.0';
+        }
+    }
+    else if (config.storage === 'external-url') {
+        if (config.databaseType === 'sql' && config.sqlOption === 'prisma') {
+            dependencies['@prisma/client'] = '^6.0.1';
+            dependencies['prisma'] = '^6.0.1';
+        }
+        else if (config.databaseType === 'sql') {
+            dependencies['typeorm'] = '^0.3.20';
+            dependencies['pg'] = '^8.13.1';
+            devDependencies['@types/pg'] = '^8.11.10';
+        }
+        else if (config.databaseType === 'nosql' && config.nosqlOption === 'mongodb') {
+            dependencies['@nestjs/mongoose'] = '^10.1.0';
+            dependencies['mongoose'] = '^8.8.4';
+        }
+        else if (config.databaseType === 'nosql' && config.nosqlOption === 'dynamodb') {
+            dependencies['@aws-sdk/client-dynamodb'] = '^3.699.0';
+            dependencies['@aws-sdk/lib-dynamodb'] = '^3.699.0';
+        }
+    }
+    // Add API type dependencies
+    if (config.apiType === 'graphql') {
+        dependencies['@nestjs/graphql'] = '^12.1.0';
+        dependencies['@nestjs/apollo'] = '^12.1.0';
+        dependencies['apollo-server-express'] = '^3.12.1';
+        dependencies['graphql'] = '^16.9.0';
+    }
+    const packageJson = {
+        name: `${config.projectName}-backend`,
+        version: '1.0.0',
+        description: '',
+        author: '',
+        private: true,
+        license: 'MIT',
+        scripts: {
+            build: 'nest build',
+            format: 'prettier --write "src/**/*.ts" "test/**/*.ts"',
+            start: 'nest start',
+            'start:dev': 'nest start --watch',
+            'start:debug': 'nest start --debug --watch',
+            'start:prod': 'node dist/main',
+            lint: 'eslint "{src,apps,libs,test}/**/*.ts" --fix',
+            test: 'vitest',
+            'test:ui': 'vitest --ui',
+            'test:coverage': 'vitest --coverage',
+            'test:e2e': 'vitest --config vitest.e2e.config.ts'
+        },
+        dependencies,
+        devDependencies: {
+            ...devDependencies,
+            '@typescript-eslint/eslint-plugin': '^8.15.0',
+            '@typescript-eslint/parser': '^8.15.0',
+            eslint: '^9.15.0',
+            'eslint-config-prettier': '^9.1.0',
+            'eslint-plugin-prettier': '^6.0.0',
+            prettier: '^3.3.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 nest-cli.json
+    const nestCli = {
+        '$schema': 'https://json.schemastore.org/nest-cli',
+        collection: '@nestjs/schematics',
+        sourceRoot: 'src',
+        compilerOptions: {
+            deleteOutDir: true
+        }
+    };
+    await fs_extra_1.default.writeJSON(path_1.default.join(backendPath, 'nest-cli.json'), nestCli, { spaces: 2 });
+    // Create tsconfig
+    const tsconfig = {
+        compilerOptions: {
+            module: 'commonjs',
+            declaration: true,
+            removeComments: true,
+            emitDecoratorMetadata: true,
+            experimentalDecorators: true,
+            allowSyntheticDefaultImports: true,
+            target: 'ES2021',
+            sourceMap: true,
+            outDir: './dist',
+            baseUrl: './',
+            incremental: true,
+            skipLibCheck: true,
+            strictNullChecks: false,
+            noImplicitAny: false,
+            strictBindCallApply: false,
+            forceConsistentCasingInFileNames: false,
+            noFallthroughCasesInSwitch: false
+        }
+    };
+    await fs_extra_1.default.writeJSON(path_1.default.join(backendPath, 'tsconfig.json'), tsconfig, { spaces: 2 });
+    // Create src directory structure
+    const srcPath = path_1.default.join(backendPath, 'src');
+    await fs_extra_1.default.ensureDir(srcPath);
+    // Create main.ts
+    let mainContent = `import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  app.enableCors();
+  await app.listen(process.env.PORT || 3001);
+  console.log(\`Application is running on: http://localhost:\${process.env.PORT || 3001}\`);
+}
+bootstrap();
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(srcPath, 'main.ts'), mainContent);
+    // Create app.module.ts
+    let appModuleContent = `import { Module } from '@nestjs/common';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+`;
+    if (config.apiType === 'graphql') {
+        appModuleContent += `import { GraphQLModule } from '@nestjs/graphql';
+import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
+import { join } from 'path';
+
+`;
+    }
+    appModuleContent += `
+@Module({
+  imports: [
+`;
+    if (config.apiType === 'graphql') {
+        appModuleContent += `    GraphQLModule.forRoot<ApolloDriverConfig>({
+      driver: ApolloDriver,
+      autoSchemaFile: join(process.cwd(), 'src/schema.gql'),
+      sortSchema: true,
+    }),
+`;
+    }
+    appModuleContent += `  ],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(srcPath, 'app.module.ts'), appModuleContent);
+    // Create app.controller.ts
+    const appController = `import { Controller, Get } from '@nestjs/common';
+import { AppService } from './app.service';
+
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getHello(): string {
+    return this.appService.getHello();
+  }
+
+  @Get('health')
+  getHealth() {
+    return { status: 'ok', message: 'Server is running' };
+  }
+}
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(srcPath, 'app.controller.ts'), appController);
+    // Create app.service.ts
+    const appService = `import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class AppService {
+  getHello(): string {
+    return 'Hello World!';
+  }
+}
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(srcPath, 'app.service.ts'), appService);
+    // Create .env.example
+    let envExample = `PORT=3001
+`;
+    if (config.storage === 'external-url' && config.databaseUrl) {
+        envExample += `DATABASE_URL=${config.databaseUrl}\n`;
+    }
+    await fs_extra_1.default.writeFile(path_1.default.join(backendPath, '.env.example'), envExample);
+    // Create Vitest config
+    const vitestConfig = `import { defineConfig } from 'vitest/config'
+import path from 'path'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+    },
+  },
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src'),
+    },
+  },
+})
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(backendPath, 'vitest.config.ts'), vitestConfig);
+    // Create test files
+    const testPath = path_1.default.join(srcPath, '__tests__');
+    await fs_extra_1.default.ensureDir(testPath);
+    const appControllerTest = `import { describe, it, expect, beforeEach } from 'vitest'
+import { Test, TestingModule } from '@nestjs/testing'
+import { AppController } from '../app.controller'
+import { AppService } from '../app.service'
+
+describe('AppController', () => {
+  let appController: AppController
+  let appService: AppService
+
+  beforeEach(async () => {
+    const moduleRef: TestingModule = await Test.createTestingModule({
+      controllers: [AppController],
+      providers: [AppService],
+    }).compile()
+
+    appService = moduleRef.get<AppService>(AppService)
+    appController = moduleRef.get<AppController>(AppController)
+  })
+
+  it('should return "Hello World!"', () => {
+    expect(appController.getHello()).toBe('Hello World!')
+  })
+
+  it('should return health check', () => {
+    const result = appController.getHealth()
+    expect(result.status).toBe('ok')
+  })
+})
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(testPath, 'app.controller.spec.ts'), appControllerTest);
+    const appServiceTest = `import { describe, it, expect } from 'vitest'
+import { AppService } from '../app.service'
+
+describe('AppService', () => {
+  it('should return "Hello World!"', () => {
+    const appService = new AppService()
+    expect(appService.getHello()).toBe('Hello World!')
+  })
+})
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(testPath, 'app.service.spec.ts'), appServiceTest);
+    // Create database setup if needed
+    if (config.databaseType === 'sql' && config.sqlOption === 'prisma') {
+        await generatePrismaConfig(backendPath, config);
+    }
+    else if (config.databaseType === 'nosql' && config.nosqlOption === 'mongodb') {
+        await generateMongoDBModule(srcPath, config);
+    }
+    // Create deployment files
+    await generateBackendDeployment(backendPath, config);
+}
+async function generatePrismaConfig(backendPath, config) {
+    const prismaPath = path_1.default.join(backendPath, 'prisma');
+    await fs_extra_1.default.ensureDir(prismaPath);
+    let datasource = '';
+    if (config.storage === 'local-sqlite') {
+        datasource = `datasource db {
+  provider = "sqlite"
+  url      = "file:./dev.db"
+}`;
+    }
+    else if (config.storage === 'external-url') {
+        datasource = `datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}`;
+    }
+    const schema = `${datasource}
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+model User {
+  id        Int      @id @default(autoincrement())
+  email     String   @unique
+  name      String?
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(prismaPath, 'schema.prisma'), schema);
+}
+async function generateMongoDBModule(srcPath, config) {
+    const dbContent = `import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { User, UserSchema } from './schemas/user.schema';
+
+@Module({
+  imports: [
+    MongooseModule.forRoot(process.env.DATABASE_URL || 'mongodb://localhost:27017/${config.projectName}'),
+    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+  ],
+  exports: [MongooseModule],
+})
+export class DatabaseModule {}
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(srcPath, 'database.module.ts'), dbContent);
+    const schemasPath = path_1.default.join(srcPath, 'schemas');
+    await fs_extra_1.default.ensureDir(schemasPath);
+    const userSchema = `import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { Document } from 'mongoose';
+
+export type UserDocument = User & Document;
+
+@Schema()
+export class User {
+  @Prop({ required: true, unique: true })
+  email: string;
+
+  @Prop()
+  name: string;
+
+  @Prop({ default: Date.now })
+  createdAt: Date;
+}
+
+export const UserSchema = SchemaFactory.createForClass(User);
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(schemasPath, 'user.schema.ts'), userSchema);
+}
+async function generateBackendDeployment(backendPath, config) {
+    // Render configuration
+    const renderYaml = `services:
+  - type: web
+    name: ${config.projectName}-backend
+    env: node
+    buildCommand: npm install && npm run build
+    startCommand: npm run start:prod
+    envVars:
+      - key: NODE_ENV
+        value: production
+      - key: PORT
+        value: 3001
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(backendPath, 'render.yaml'), renderYaml);
+}

package/dist/templates/backend/sam.js

@@ -0,0 +1,258 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSAM = generateSAM;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+async function generateSAM(backendPath, config) {
+    // Create root package.json with SAM scripts
+    const rootPackageJson = {
+        name: `${config.projectName}-backend`,
+        version: '1.0.0',
+        private: true,
+        scripts: {
+            'build': 'sam build',
+            'deploy': 'sam deploy',
+            'deploy:guided': 'sam deploy --guided',
+            'local': 'sam local start-api',
+            'validate': 'sam validate',
+            'synth': 'sam build && sam deploy --no-execute'
+        },
+        devDependencies: {}
+    };
+    await fs_extra_1.default.writeJSON(path_1.default.join(backendPath, 'package.json'), rootPackageJson, { spaces: 2 });
+    // Create template.yaml
+    let templateContent = `AWSTemplateFormatVersion: '2010-09-09'
+Transform: AWS::Serverless-2016-10-31
+Description: >
+  ${config.projectName}
+  SAM Template for ${config.projectName}
+
+Globals:
+  Function:
+    Timeout: 3
+    MemorySize: 128
+
+Resources:
+  HelloWorldFunction:
+    Type: AWS::Serverless::Function
+    Properties:
+      CodeUri: hello-world/
+      Handler: app.lambdaHandler
+      Runtime: nodejs18.x
+      Architectures:
+        - x86_64
+      Events:
+        HelloWorld:
+          Type: Api
+          Properties:
+            Path: /hello
+            Method: get
+        HelloWorldPost:
+          Type: Api
+          Properties:
+            Path: /hello
+            Method: post
+
+`;
+    if (config.databaseType === 'nosql') {
+        templateContent += `  DynamoDBTable:
+    Type: AWS::DynamoDB::Table
+    Properties:
+      TableName: ${config.projectName}Table
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+        - AttributeName: id
+          AttributeType: S
+      KeySchema:
+        - AttributeName: id
+          KeyType: HASH
+
+`;
+    }
+    else if (config.databaseType === 'sql') {
+        templateContent += `  # Note: RDS requires VPC configuration
+  # You'll need to add VPC, Subnets, and Security Groups manually
+  # or use AWS RDS Proxy for serverless access
+
+`;
+    }
+    templateContent += `Outputs:
+  HelloWorldApi:
+    Description: "API Gateway endpoint URL for Prod stage for Hello World function"
+    Value: !Sub "https://\${ServerlessRestApi}.execute-api.\${AWS::Region}.amazonaws.com/Prod/hello/"
+  HelloWorldFunction:
+    Description: "Hello World Lambda Function ARN"
+    Value: !GetAtt HelloWorldFunction.Arn
+  HelloWorldFunctionIamRole:
+    Description: "Implicit IAM Role created for Hello World function"
+    Value: !GetAtt HelloWorldFunctionRole.Arn
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(backendPath, 'template.yaml'), templateContent);
+    // Create hello-world function
+    const helloWorldPath = path_1.default.join(backendPath, 'hello-world');
+    await fs_extra_1.default.ensureDir(helloWorldPath);
+    const packageJson = {
+        name: 'hello-world',
+        version: '1.0.0',
+        description: 'Hello World SAM Lambda function',
+        main: 'app.js',
+        scripts: {
+            test: 'node tests/unit/test-handler.js'
+        },
+        dependencies: {}
+    };
+    if (config.databaseType === 'nosql') {
+        packageJson.dependencies = {
+            '@aws-sdk/client-dynamodb': '^3.699.0',
+            '@aws-sdk/lib-dynamodb': '^3.699.0'
+        };
+    }
+    await fs_extra_1.default.writeJSON(path_1.default.join(helloWorldPath, 'package.json'), packageJson, { spaces: 2 });
+    let appJs = `exports.lambdaHandler = async (event) => {
+    try {
+        const response = {
+            statusCode: 200,
+            body: JSON.stringify({
+                message: 'Hello from ${config.projectName}!',
+                input: event,
+            }),
+        };
+        return response;
+    } catch (err) {
+        console.log(err);
+        return err;
+    }
+};
+`;
+    if (config.databaseType === 'nosql') {
+        appJs = `const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');
+const { DynamoDBDocumentClient, PutCommand, GetCommand } = require('@aws-sdk/lib-dynamodb');
+
+const client = new DynamoDBClient({});
+const docClient = DynamoDBDocumentClient.from(client);
+
+const TABLE_NAME = process.env.TABLE_NAME || '${config.projectName}Table';
+
+exports.lambdaHandler = async (event) => {
+    try {
+        const response = {
+            statusCode: 200,
+            body: JSON.stringify({
+                message: 'Hello from ${config.projectName}!',
+                input: event,
+            }),
+        };
+        return response;
+    } catch (err) {
+        console.log(err);
+        return {
+            statusCode: 500,
+            body: JSON.stringify({ error: err.message }),
+        };
+    }
+};
+`;
+    }
+    await fs_extra_1.default.writeFile(path_1.default.join(helloWorldPath, 'app.js'), appJs);
+    // Create test directory and test file
+    const testsPath = path_1.default.join(helloWorldPath, 'tests', 'unit');
+    await fs_extra_1.default.ensureDir(testsPath);
+    const testFile = `import { describe, it, expect } from 'vitest';
+const app = require('../../app');
+
+describe('Tests index', () => {
+    it('verifies successful response', async () => {
+        const event = {
+            httpMethod: 'GET',
+            path: '/hello'
+        };
+        const context = {};
+        
+        const result = await app.lambdaHandler(event, context);
+        
+        expect(result).toBeDefined();
+        expect(result.statusCode).toBe(200);
+        
+        const response = JSON.parse(result.body);
+        expect(response.message).toBeDefined();
+    });
+});
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(testsPath, 'test-handler.js'), testFile);
+    // Create package.json for tests
+    const testPackageJson = {
+        name: 'hello-world-tests',
+        version: '1.0.0',
+        scripts: {
+            test: 'vitest',
+            'test:ui': 'vitest --ui',
+            'test:coverage': 'vitest --coverage'
+        },
+        dependencies: {
+            'aws-sdk': '^2.814.0'
+        },
+        devDependencies: {
+            '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(testsPath, 'package.json'), testPackageJson, { spaces: 2 });
+    // Create samconfig.toml
+    const samConfig = `version = 0.1
+
+[default]
+[default.global.parameters]
+stack_name = "${config.projectName}"
+
+[default.build.parameters]
+cached = true
+parallel = true
+
+[default.validate.parameters]
+lint = true
+
+[default.deploy.parameters]
+capabilities = "CAPABILITY_IAM"
+confirm_changeset = true
+resolve_s3 = true
+region = "us-east-1"
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(backendPath, 'samconfig.toml'), samConfig);
+    // Create README
+    const readme = `# AWS SAM Backend
+
+This is an AWS SAM project for serverless deployment.
+
+## Prerequisites
+
+- AWS CLI configured
+- SAM CLI installed (\`pip install aws-sam-cli\`)
+
+## Build and Deploy
+
+\`\`\`bash
+npm run build
+npm run deploy:guided
+\`\`\`
+
+## Local Development
+
+\`\`\`bash
+npm run local
+\`\`\`
+
+## Useful Commands
+
+- \`npm run build\` - Build your application
+- \`npm run local\` - Start local API Gateway
+- \`npm run deploy:guided\` - Deploy your application with guided prompts
+- \`npm run deploy\` - Deploy your application
+- \`npm run validate\` - Validate SAM template
+- \`sam logs -n HelloWorldFunction --stack-name ${config.projectName} --tail\` - View logs
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(backendPath, 'README.md'), readme);
+}