build-app-with 2.0.0

package/src/generators/fastify/templates/app.js

@@ -0,0 +1,179 @@
+/**
+ * Generate main Fastify app.js file
+ */
+
+import { FEATURES, DATABASES } from '../../../types/index.js';
+import { hasFeature } from '../../../utils/answer-helpers.js';
+
+export function generateAppJs(projectPath, answers) {
+    let content = `import Fastify from 'fastify';
+import cors from '@fastify/cors';
+import helmet from '@fastify/helmet';
+import rateLimit from '@fastify/rate-limit';
+import env from '@fastify/env';
+import { logger } from './utils/logger.js';
+import { errorHandler } from './plugins/errorHandler.js';
+import { notFound } from './plugins/notFound.js';
+
+// Environment schema
+const envSchema = {
+  type: 'object',
+  required: ['PORT'],
+  properties: {
+    PORT: {
+      type: 'string',
+      default: '3000'
+    },
+    NODE_ENV: {
+      type: 'string',
+      default: 'development'
+    },
+    HOST: {
+      type: 'string',
+      default: '0.0.0.0'
+    }
+`;
+
+    // Add database environment variables
+    if (answers.database === DATABASES.MONGODB) {
+        content += `    MONGODB_URI: {
+      type: 'string',
+      default: 'mongodb://localhost:27017/${answers.projectName}'
+    }
+`;
+    } else if (answers.database === DATABASES.POSTGRESQL || answers.database === DATABASES.SQLITE) {
+        content += `    DATABASE_URL: {
+      type: 'string',
+      default: '${answers.database === DATABASES.POSTGRESQL ? 'postgresql://username:password@localhost:5432/' : 'file:./dev.db'}${answers.projectName}'
+    }
+`;
+    } else if (answers.database === DATABASES.MYSQL) {
+        content += `    DB_HOST: {
+      type: 'string',
+      default: 'localhost'
+    },
+    DB_PORT: {
+      type: 'string',
+      default: '3306'
+    },
+    DB_NAME: {
+      type: 'string',
+      default: '${answers.projectName}'
+    },
+    DB_USER: {
+      type: 'string',
+      default: 'root'
+    },
+    DB_PASSWORD: {
+      type: 'string',
+      default: 'password'
+    }
+`;
+    }
+
+    // Add authentication environment variables
+    if (answers.authStrategy && answers.authStrategy !== 'none') {
+        content += `    JWT_SECRET: {
+      type: 'string',
+      default: 'your-super-secret-jwt-key'
+    },
+    JWT_EXPIRES_IN: {
+      type: 'string',
+      default: '7d'
+    }
+`;
+    }
+
+    // Add CORS environment variables
+    if (answers.features && answers.features.includes(FEATURES.CORS)) {
+        content += `    CORS_ORIGIN: {
+      type: 'string',
+      default: 'http://localhost:3000'
+    }
+`;
+    }
+
+    // Add rate limiting environment variables
+    if (hasFeature(answers, 'rate-limit')) {
+        content += `    RATE_LIMIT_MAX: {
+      type: 'string',
+      default: '100'
+    },
+    RATE_LIMIT_TIME_WINDOW: {
+      type: 'string',
+      default: '60000'
+    }
+`;
+    }
+
+    content += `  }
+};
+
+export async function buildApp() {
+  const fastify = Fastify({
+    logger: {
+      level: process.env.LOG_LEVEL || 'info',
+      transport: process.env.NODE_ENV === 'development' ? {
+        target: 'pino-pretty',
+        options: {
+          colorize: true
+        }
+      } : undefined
+    }
+  });
+
+  // Register environment plugin
+  await fastify.register(env, { schema: envSchema });
+
+  // Register security plugins
+  await fastify.register(helmet);
+
+  // Register CORS plugin
+  if (hasFeature(answers, 'cors')) {
+    await fastify.register(cors, {
+      origin: fastify.config.CORS_ORIGIN || 'http://localhost:3000',
+      credentials: true
+    });
+  }
+
+  // Register rate limiting plugin
+  if (answers.features.includes('rate-limit')) {
+    await fastify.register(rateLimit, {
+      max: parseInt(fastify.config.RATE_LIMIT_MAX) || 100,
+      timeWindow: parseInt(fastify.config.RATE_LIMIT_TIME_WINDOW) || 60000
+    });
+  }
+
+  // Register custom plugins
+  await fastify.register(errorHandler);
+  await fastify.register(notFound);
+
+  // Health check endpoint
+  fastify.get('/health', async (request, reply) => {
+    return {
+      status: 'OK',
+      timestamp: new Date().toISOString(),
+      uptime: process.uptime(),
+      environment: fastify.config.NODE_ENV,
+      version: '1.0.0'
+    };
+  });
+
+  // API routes
+  fastify.get('/api', async (request, reply) => {
+    return {
+      message: 'Welcome to ${answers.projectName} API',
+      version: '1.0.0',
+      endpoints: {
+        health: '/health',
+        api: '/api'
+      }
+    };
+  });
+
+  return fastify;
+}
+`;
+
+    return content;
+}

package/src/generators/fastify/templates/config.js

@@ -0,0 +1,33 @@
+/**
+ * Generate Fastify config template
+ */
+
+export function generateConfig(projectPath, answers) {
+    const configContent = `export const config = {
+  port: process.env.PORT || 3000,
+  host: process.env.HOST || '0.0.0.0',
+  nodeEnv: process.env.NODE_ENV || 'development',
+  corsOrigin: process.env.CORS_ORIGIN || 'http://localhost:3000',
+  database: {
+    url: process.env.DATABASE_URL || process.env.MONGODB_URI,
+    host: process.env.DB_HOST || 'localhost',
+    port: process.env.DB_PORT || 3306,
+    name: process.env.DB_NAME || '${answers.projectName}',
+    user: process.env.DB_USER || 'root',
+    password: process.env.DB_PASSWORD || 'password'
+  },
+  auth: {
+    jwtSecret: process.env.JWT_SECRET || 'your-secret-key',
+    jwtExpiresIn: process.env.JWT_EXPIRES_IN || '7d'
+  },
+  rateLimit: {
+    max: parseInt(process.env.RATE_LIMIT_MAX) || 100,
+    timeWindow: parseInt(process.env.RATE_LIMIT_TIME_WINDOW) || 60000
+  }
+};
+
+export default config;
+`;
+
+    return configContent;
+}

package/src/generators/fastify/templates/docker.js

@@ -0,0 +1,73 @@
+/**
+ * Generate Fastify Docker template
+ */
+
+export function generateDocker(projectPath, answers) {
+    const dockerfile = `# Use Node.js LTS version
+FROM node:18-alpine
+
+# Set working directory
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci --only=production
+
+# Copy source code
+COPY . .
+
+# Create non-root user
+RUN addgroup -g 1001 -S nodejs
+RUN adduser -S nextjs -u 1001
+
+# Change ownership
+RUN chown -R nextjs:nodejs /app
+USER nextjs
+
+# Expose port
+EXPOSE 3000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \\
+  CMD curl -f http://localhost:3000/health || exit 1
+
+# Start the application
+CMD ["npm", "start"]
+`;
+
+    const dockerCompose = `version: '3.8'
+
+services:
+  app:
+    build: .
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+      - PORT=3000
+      - HOST=0.0.0.0
+    depends_on:
+      - db
+    restart: unless-stopped
+
+  db:
+    image: ${answers.database === 'mongodb' ? 'mongo:latest' : 'postgres:15-alpine'}
+    environment:
+      ${answers.database === 'mongodb'
+            ? 'MONGO_INITDB_DATABASE=myapp'
+            : 'POSTGRES_DB=myapp\n      POSTGRES_USER=postgres\n      POSTGRES_PASSWORD=password'
+        }
+    volumes:
+      - db_data:/data/db
+    ports:
+      - "${answers.database === 'mongodb' ? '27017:27017' : '5432:5432'}"
+    restart: unless-stopped
+
+volumes:
+  db_data:
+`;
+
+    return { dockerfile, dockerCompose };
+}

package/src/generators/fastify/templates/models.js

@@ -0,0 +1,77 @@
+/**
+ * Generate Fastify models template
+ */
+
+import { DATABASES } from '../../../types/index.js';
+
+export function generateModels(projectPath, answers) {
+    if (answers.database === DATABASES.MONGODB) {
+        return generateMongooseModels(answers);
+    } else if (answers.database === DATABASES.POSTGRESQL || answers.database === DATABASES.SQLITE) {
+        return generatePrismaModels(answers);
+    } else if (answers.database === DATABASES.MYSQL) {
+        return generateSequelizeModels(answers);
+    }
+    return '';
+}
+
+function generateMongooseModels(answers) {
+    return `import mongoose from 'mongoose';
+
+const userSchema = new mongoose.Schema({
+  name: {
+    type: String,
+    required: true,
+    trim: true
+  },
+  email: {
+    type: String,
+    required: true,
+    unique: true,
+    lowercase: true,
+    trim: true
+  },
+  password: {
+    type: String,
+    required: true,
+    minlength: 6
+  }
+}, {
+  timestamps: true
+});
+
+export const User = mongoose.model('User', userSchema);
+`;
+}
+
+function generatePrismaModels(answers) {
+    return `// Prisma schema will be generated in schema.prisma
+// This is a placeholder for Prisma models
+
+export const prisma = new PrismaClient();
+`;
+}
+
+function generateSequelizeModels(answers) {
+    return `import { DataTypes } from 'sequelize';
+import { sequelize } from '../config/database.js';
+
+export const User = sequelize.define('User', {
+  name: {
+    type: DataTypes.STRING,
+    allowNull: false
+  },
+  email: {
+    type: DataTypes.STRING,
+    allowNull: false,
+    unique: true
+  },
+  password: {
+    type: DataTypes.STRING,
+    allowNull: false
+  }
+}, {
+  timestamps: true
+});
+`;
+}

package/src/generators/fastify/templates/package-json.js

@@ -0,0 +1,57 @@
+/**
+ * Generate package.json for Fastify project
+ */
+
+import { FRAMEWORKS, DATABASES, AUTH_STRATEGIES } from '../../../types/index.js';
+
+export function generatePackageJson(answers) {
+    const basePackage = {
+        name: answers.projectName,
+        version: '1.0.0',
+        description: `A production-ready Fastify application - ${answers.projectName}`,
+        main: 'src/server.js',
+        type: 'module',
+        scripts: {
+            start: 'node src/server.js',
+            dev: 'nodemon src/server.js',
+            test: answers.includeTests ? 'jest' : undefined,
+            'test:watch': answers.includeTests ? 'jest --watch' : undefined,
+            'test:coverage': answers.includeTests ? 'jest --coverage' : undefined,
+            'test:tap': answers.includeTests ? 'tap test/**/*.test.js' : undefined
+        },
+        keywords: [
+            'fastify',
+            'nodejs',
+            'api',
+            'backend',
+            'server',
+            'rest',
+            'production-ready',
+            'high-performance'
+        ],
+        author: 'Generated by build-app-with',
+        license: 'MIT',
+        engines: {
+            node: '>=18.0.0'
+        },
+        dependencies: {},
+        devDependencies: {}
+    };
+
+    // Add database-specific scripts
+    if (answers.database === DATABASES.POSTGRESQL || answers.database === DATABASES.SQLITE) {
+        basePackage.scripts['db:generate'] = 'prisma generate';
+        basePackage.scripts['db:push'] = 'prisma db push';
+        basePackage.scripts['db:migrate'] = 'prisma migrate dev';
+        basePackage.scripts['db:studio'] = 'prisma studio';
+    }
+
+    // Remove undefined scripts
+    Object.keys(basePackage.scripts).forEach(key => {
+        if (basePackage.scripts[key] === undefined) {
+            delete basePackage.scripts[key];
+        }
+    });
+
+    return basePackage;
+}

package/src/generators/fastify/templates/plugins.js

@@ -0,0 +1,38 @@
+/**
+ * Generate Fastify plugins template
+ */
+
+export function generatePlugins(projectPath, answers) {
+    const pluginsContent = `import fp from 'fastify-plugin';
+
+// Error handler plugin
+export default fp(async function (fastify, opts) {
+  fastify.setErrorHandler(async (error, request, reply) => {
+    fastify.log.error(error);
+    
+    const statusCode = error.statusCode || 500;
+    const message = error.message || 'Internal Server Error';
+    
+    reply.status(statusCode).send({
+      error: true,
+      message,
+      statusCode,
+      ...(process.env.NODE_ENV === 'development' && { stack: error.stack })
+    });
+  });
+
+  // Not found handler
+  fastify.setNotFoundHandler(async (request, reply) => {
+    reply.status(404).send({
+      error: true,
+      message: \`Route \${request.method}:\${request.url} not found\`,
+      statusCode: 404
+    });
+  });
+}, {
+  name: 'error-handler'
+});
+`;
+
+    return pluginsContent;
+}