boiling-fullstack 0.1.0

package/dist/utils/shell.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setVerbose = setVerbose;
+exports.runCommand = runCommand;
+exports.checkCommand = checkCommand;
+exports.checkEnvironment = checkEnvironment;
+exports.gitInit = gitInit;
+exports.npmInstall = npmInstall;
+const execa_1 = __importDefault(require("execa"));
+const chalk_1 = __importDefault(require("chalk"));
+let verbose = false;
+function setVerbose(v) {
+    verbose = v;
+}
+async function runCommand(command, args, cwd) {
+    try {
+        await (0, execa_1.default)(command, args, { cwd, stdio: verbose ? 'inherit' : 'ignore' });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`Command "${command}" not found. Make sure it is installed and available in your PATH.`);
+        }
+        throw new Error(`Command "${command} ${args.join(' ')}" failed: ${error.shortMessage || error.message}`);
+    }
+}
+async function checkCommand(cmd) {
+    try {
+        await (0, execa_1.default)(cmd, ['--version'], { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function checkEnvironment() {
+    const hasGit = await checkCommand('git');
+    if (!hasGit) {
+        throw new Error('git is required but was not found. Please install git before continuing.');
+    }
+    const hasDocker = await checkCommand('docker');
+    if (!hasDocker) {
+        console.warn(chalk_1.default.yellow('⚠ docker not found. The project will be generated but "make up" requires Docker.'));
+    }
+}
+async function gitInit(cwd) {
+    await runCommand('git', ['init'], cwd);
+}
+async function npmInstall(cwd) {
+    await runCommand('npm', ['install'], cwd);
+}

package/dist/utils/template.d.ts

@@ -0,0 +1,2 @@
+export declare function renderTemplateFile(templatePath: string, outputPath: string, data: Record<string, unknown>): Promise<void>;
+export declare function copyAndRenderDir(templateDir: string, outputDir: string, data: Record<string, unknown>): Promise<void>;

package/dist/utils/template.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTemplateFile = renderTemplateFile;
+exports.copyAndRenderDir = copyAndRenderDir;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const ejs_1 = __importDefault(require("ejs"));
+async function renderTemplateFile(templatePath, outputPath, data) {
+    const template = await fs_extra_1.default.readFile(templatePath, 'utf-8');
+    const rendered = ejs_1.default.render(template, data, { filename: templatePath });
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(outputPath));
+    await fs_extra_1.default.writeFile(outputPath, rendered);
+}
+async function copyAndRenderDir(templateDir, outputDir, data) {
+    const files = await getAllFiles(templateDir);
+    for (const filePath of files) {
+        const relativePath = path_1.default.relative(templateDir, filePath);
+        let outputName = relativePath;
+        const isEjs = outputName.endsWith('.ejs');
+        if (isEjs) {
+            outputName = outputName.slice(0, -4);
+        }
+        // Rename gitignore → .gitignore (npm strips dotfiles on publish)
+        outputName = outputName.replace(/(^|\/)gitignore$/, '$1.gitignore');
+        const outputPath = path_1.default.join(outputDir, outputName);
+        if (isEjs) {
+            await renderTemplateFile(filePath, outputPath, data);
+        }
+        else {
+            await fs_extra_1.default.ensureDir(path_1.default.dirname(outputPath));
+            await fs_extra_1.default.copy(filePath, outputPath);
+        }
+    }
+}
+async function getAllFiles(dir) {
+    const entries = await fs_extra_1.default.readdir(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await getAllFiles(fullPath)));
+        }
+        else {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}

package/dist/utils/validation.d.ts

@@ -0,0 +1,6 @@
+import type { ValidationResult } from '../types';
+export declare function isValidProjectName(name: string): ValidationResult;
+export declare function isValidServiceName(name: string, usedNames: string[]): ValidationResult;
+export declare function isValidPort(port: number, usedPorts: number[]): ValidationResult;
+export declare function generatePassword(length?: number): string;
+export declare function generateJwtSecret(length?: number): string;

package/dist/utils/validation.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.isValidProjectName = isValidProjectName;
+exports.isValidServiceName = isValidServiceName;
+exports.isValidPort = isValidPort;
+exports.generatePassword = generatePassword;
+exports.generateJwtSecret = generateJwtSecret;
+const validate_npm_package_name_1 = __importDefault(require("validate-npm-package-name"));
+const crypto_1 = __importDefault(require("crypto"));
+const KEBAB_CASE_REGEX = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+const RESERVED_SERVICE_NAMES = ['backend', 'db', 'pgadmin', 'adminer'];
+function isValidProjectName(name) {
+    if (!name)
+        return 'Project name is required';
+    const result = (0, validate_npm_package_name_1.default)(name);
+    if (!result.validForNewPackages) {
+        const errors = [...(result.errors || []), ...(result.warnings || [])];
+        return errors[0] || 'Invalid project name';
+    }
+    if (!KEBAB_CASE_REGEX.test(name)) {
+        return 'Name must be in kebab-case (e.g. my-project)';
+    }
+    return true;
+}
+function isValidServiceName(name, usedNames) {
+    if (!name)
+        return 'Service name is required';
+    if (!KEBAB_CASE_REGEX.test(name)) {
+        return 'Name must be in kebab-case (e.g. my-frontend)';
+    }
+    if (RESERVED_SERVICE_NAMES.includes(name)) {
+        return `Name "${name}" is reserved`;
+    }
+    if (usedNames.includes(name)) {
+        return `Name "${name}" is already taken`;
+    }
+    return true;
+}
+function isValidPort(port, usedPorts) {
+    if (!Number.isInteger(port))
+        return 'Port must be an integer';
+    if (port < 1024 || port > 65535)
+        return 'Port must be between 1024 and 65535';
+    if (port === 5432)
+        return 'Port 5432 is reserved for PostgreSQL';
+    if (usedPorts.includes(port)) {
+        return `Port ${port} is already in use`;
+    }
+    return true;
+}
+function generatePassword(length = 16) {
+    return crypto_1.default.randomBytes(length).toString('base64url').slice(0, length);
+}
+function generateJwtSecret(length = 32) {
+    return crypto_1.default.randomBytes(length).toString('hex');
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "boiling-fullstack",
+  "version": "0.1.0",
+  "description": "CLI to scaffold fullstack projects with Docker, NestJS backend, and Vue/Nuxt frontends",
+  "main": "dist/index.js",
+  "bin": {
+    "boiling": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["cli", "scaffold", "fullstack", "docker", "nuxt", "vue", "nestjs"],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "chalk": "^4.1.2",
+    "commander": "^12.1.0",
+    "ejs": "^3.1.10",
+    "execa": "^5.1.1",
+    "fs-extra": "^11.2.0",
+    "picocolors": "^1.1.1",
+    "validate-npm-package-name": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/ejs": "^3.1.5",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.10.0",
+    "@types/validate-npm-package-name": "^4.0.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.0"
+  }
+}

package/templates/backend/nestjs/.dockerignore

@@ -0,0 +1,3 @@
+node_modules
+dist
+.git

package/templates/backend/nestjs/.eslintrc.cjs.ejs

@@ -0,0 +1,19 @@
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    project: 'tsconfig.json',
+    tsconfigRootDir: __dirname,
+    sourceType: 'module',
+  },
+  plugins: ['@typescript-eslint/eslint-plugin'],
+  extends: [
+    'plugin:@typescript-eslint/recommended',
+  ],
+  root: true,
+  env: {
+    node: true,
+    jest: true,
+  },
+  ignorePatterns: ['.eslintrc.cjs'],
+  rules: {},
+}

package/templates/backend/nestjs/.prettierrc

@@ -0,0 +1,6 @@
+{
+  "semi": false,
+  "singleQuote": true,
+  "trailingComma": "all",
+  "printWidth": 100
+}

package/templates/backend/nestjs/Dockerfile

@@ -0,0 +1,44 @@
+# Stage 1: Development
+FROM node:20-alpine AS development
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm install
+
+COPY . .
+
+USER node
+
+EXPOSE 3001
+
+CMD ["npm", "run", "start:dev"]
+
+# Stage 2: Build
+FROM node:20-alpine AS build
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm install
+
+COPY . .
+RUN npm run build
+
+# Stage 3: Production
+FROM node:20-alpine AS production
+
+WORKDIR /app
+
+COPY --from=build /app/dist ./dist
+COPY --from=build /app/node_modules ./node_modules
+COPY --from=build /app/package*.json ./
+
+USER node
+
+EXPOSE 3001
+
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+  CMD wget --no-verbose --tries=1 --spider http://localhost:3001/health || exit 1
+
+CMD ["node", "dist/main"]

package/templates/backend/nestjs/nest-cli.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/nest-cli",
+  "collection": "@nestjs/schematics",
+  "sourceRoot": "src",
+  "compilerOptions": {
+    "deleteOutDir": true
+  }
+}

package/templates/backend/nestjs/package.json.ejs

@@ -0,0 +1,52 @@
+{
+  "name": "<%= projectName %>-backend",
+  "version": "0.0.1",
+  "private": true,
+  "scripts": {
+    "build": "nest build",
+    "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\"",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "migration:generate": "typeorm-ts-node-commonjs migration:generate -d src/config/data-source.ts",
+    "migration:run": "typeorm-ts-node-commonjs migration:run -d src/config/data-source.ts",
+    "migration:revert": "typeorm-ts-node-commonjs migration:revert -d src/config/data-source.ts"
+  },
+  "dependencies": {
+    "@nestjs/common": "^10.4.0",
+    "@nestjs/config": "^3.3.0",
+    "@nestjs/core": "^10.4.0",
+    "@nestjs/jwt": "^10.2.0",
+    "@nestjs/passport": "^10.0.0",
+    "@nestjs/platform-express": "^10.4.0",
+    "@nestjs/typeorm": "^10.0.0",
+    "bcrypt": "^5.1.1",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "passport": "^0.7.0",
+    "passport-jwt": "^4.0.1",
+    "pg": "^8.13.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.0",
+    "typeorm": "^0.3.20"
+  },
+  "devDependencies": {
+    "@nestjs/cli": "^10.4.0",
+    "@nestjs/schematics": "^10.2.0",
+    "@types/bcrypt": "^5.0.2",
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.10.0",
+    "@types/passport-jwt": "^4.0.1",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "eslint": "^8.57.0",
+    "prettier": "^3.4.0",
+    "source-map-support": "^0.5.21",
+    "ts-loader": "^9.5.0",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.7.0"
+  }
+}

package/templates/backend/nestjs/src/app.controller.ts

@@ -0,0 +1,17 @@
+import { Controller, Get } from '@nestjs/common';
+import { AppService } from './app.service';
+
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getStatus() {
+    return { status: 'ok' };
+  }
+
+  @Get('health')
+  getHealth() {
+    return { status: 'ok', timestamp: new Date().toISOString() };
+  }
+}

package/templates/backend/nestjs/src/app.module.ts.ejs

@@ -0,0 +1,20 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+import { AuthModule } from './auth/auth.module';
+import { typeOrmConfig } from './config/typeorm.config';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({ isGlobal: true }),
+    TypeOrmModule.forRootAsync({
+      useFactory: typeOrmConfig,
+    }),
+    AuthModule,
+  ],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}

package/templates/backend/nestjs/src/app.service.ts

@@ -0,0 +1,4 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class AppService {}

package/templates/backend/nestjs/src/auth/auth.controller.ts

@@ -0,0 +1,19 @@
+import { Controller, Post, Body } from '@nestjs/common';
+import { AuthService } from './auth.service';
+import { RegisterDto } from './dto/register.dto';
+import { LoginDto } from './dto/login.dto';
+
+@Controller('auth')
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+
+  @Post('register')
+  register(@Body() registerDto: RegisterDto) {
+    return this.authService.register(registerDto);
+  }
+
+  @Post('login')
+  login(@Body() loginDto: LoginDto) {
+    return this.authService.login(loginDto);
+  }
+}

package/templates/backend/nestjs/src/auth/auth.guard.ts

@@ -0,0 +1,5 @@
+import { Injectable } from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+
+@Injectable()
+export class JwtAuthGuard extends AuthGuard('jwt') {}

package/templates/backend/nestjs/src/auth/auth.module.ts

@@ -0,0 +1,28 @@
+import { Module } from '@nestjs/common';
+import { JwtModule } from '@nestjs/jwt';
+import { PassportModule } from '@nestjs/passport';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { AuthController } from './auth.controller';
+import { AuthService } from './auth.service';
+import { JwtStrategy } from './jwt.strategy';
+import { User } from './entities/user.entity';
+
+@Module({
+  imports: [
+    PassportModule.register({ defaultStrategy: 'jwt' }),
+    JwtModule.registerAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: (configService: ConfigService) => ({
+        secret: configService.get<string>('JWT_SECRET'),
+        signOptions: { expiresIn: '1d' },
+      }),
+    }),
+    TypeOrmModule.forFeature([User]),
+  ],
+  controllers: [AuthController],
+  providers: [AuthService, JwtStrategy],
+  exports: [AuthService],
+})
+export class AuthModule {}

package/templates/backend/nestjs/src/auth/auth.service.ts

@@ -0,0 +1,50 @@
+import { Injectable, UnauthorizedException, ConflictException } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import * as bcrypt from 'bcrypt';
+import { User } from './entities/user.entity';
+import { RegisterDto } from './dto/register.dto';
+import { LoginDto } from './dto/login.dto';
+
+@Injectable()
+export class AuthService {
+  constructor(
+    @InjectRepository(User)
+    private readonly userRepository: Repository<User>,
+    private readonly jwtService: JwtService,
+  ) {}
+
+  async register(registerDto: RegisterDto) {
+    const { email, password } = registerDto;
+
+    const existingUser = await this.userRepository.findOne({ where: { email } });
+    if (existingUser) {
+      throw new ConflictException('Email already exists');
+    }
+
+    const hashedPassword = await bcrypt.hash(password, 10);
+    const user = this.userRepository.create({ email, password: hashedPassword });
+    await this.userRepository.save(user);
+
+    const payload = { sub: user.id, email: user.email };
+    return { accessToken: this.jwtService.sign(payload) };
+  }
+
+  async login(loginDto: LoginDto) {
+    const { email, password } = loginDto;
+
+    const user = await this.userRepository.findOne({ where: { email } });
+    if (!user) {
+      throw new UnauthorizedException('Invalid credentials');
+    }
+
+    const isPasswordValid = await bcrypt.compare(password, user.password);
+    if (!isPasswordValid) {
+      throw new UnauthorizedException('Invalid credentials');
+    }
+
+    const payload = { sub: user.id, email: user.email };
+    return { accessToken: this.jwtService.sign(payload) };
+  }
+}

package/templates/backend/nestjs/src/auth/dto/login.dto.ts

@@ -0,0 +1,10 @@
+import { IsEmail, IsString, MinLength } from 'class-validator';
+
+export class LoginDto {
+  @IsEmail()
+  email: string;
+
+  @IsString()
+  @MinLength(8)
+  password: string;
+}

package/templates/backend/nestjs/src/auth/dto/register.dto.ts

@@ -0,0 +1,10 @@
+import { IsEmail, IsString, MinLength } from 'class-validator';
+
+export class RegisterDto {
+  @IsEmail()
+  email: string;
+
+  @IsString()
+  @MinLength(8)
+  password: string;
+}

package/templates/backend/nestjs/src/auth/entities/user.entity.ts

@@ -0,0 +1,25 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  CreateDateColumn,
+  UpdateDateColumn,
+} from 'typeorm';
+
+@Entity('users')
+export class User {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ unique: true })
+  email: string;
+
+  @Column()
+  password: string;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+}

package/templates/backend/nestjs/src/auth/jwt.strategy.ts

@@ -0,0 +1,19 @@
+import { Injectable } from '@nestjs/common';
+import { PassportStrategy } from '@nestjs/passport';
+import { ExtractJwt, Strategy } from 'passport-jwt';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy) {
+  constructor(configService: ConfigService) {
+    super({
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      ignoreExpiration: false,
+      secretOrKey: configService.get<string>('JWT_SECRET'),
+    });
+  }
+
+  validate(payload: { sub: number; email: string }) {
+    return { id: payload.sub, email: payload.email };
+  }
+}

package/templates/backend/nestjs/src/config/data-source.ts

@@ -0,0 +1,9 @@
+import { DataSource } from 'typeorm';
+import { join } from 'path';
+
+export default new DataSource({
+  type: 'postgres',
+  url: process.env.DATABASE_URL,
+  entities: [join(__dirname, '..', '**', '*.entity.{ts,js}')],
+  migrations: [join(__dirname, '..', 'migrations', '*.{ts,js}')],
+});

package/templates/backend/nestjs/src/config/typeorm.config.ts.ejs

@@ -0,0 +1,8 @@
+import { TypeOrmModuleOptions } from '@nestjs/typeorm';
+
+export const typeOrmConfig = (): TypeOrmModuleOptions => ({
+  type: 'postgres',
+  url: process.env.DATABASE_URL,
+  autoLoadEntities: true,
+  synchronize: process.env.NODE_ENV !== 'production',
+});

package/templates/backend/nestjs/src/main.ts.ejs

@@ -0,0 +1,20 @@
+import { NestFactory } from '@nestjs/core';
+import { ValidationPipe } from '@nestjs/common';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+
+  app.useGlobalPipes(
+    new ValidationPipe({
+      whitelist: true,
+      forbidNonWhitelisted: true,
+      transform: true,
+    }),
+  );
+
+  app.enableCors();
+
+  await app.listen(3001);
+}
+bootstrap();

package/templates/backend/nestjs/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/templates/backend/nestjs/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "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
+  }
+}

package/templates/frontend/nuxt/.dockerignore

@@ -0,0 +1,5 @@
+node_modules
+.nuxt
+.output
+dist
+.git

package/templates/frontend/nuxt/.eslintrc.cjs.ejs

@@ -0,0 +1,5 @@
+module.exports = {
+  root: true,
+  extends: ['@nuxt/eslint-config'],
+  rules: {},
+}