projects-init-cli 1.1.0

package/dist/templates/backend/express.js

@@ -0,0 +1,427 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateExpress = generateExpress;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+async function generateExpress(backendPath, config) {
+    const dependencies = {
+        express: '^4.21.1',
+        cors: '^2.8.5',
+        dotenv: '^16.4.5'
+    };
+    const devDependencies = {
+        '@types/express': '^5.0.0',
+        '@types/cors': '^2.8.17',
+        '@types/node': '^22.7.5',
+        typescript: '^5.6.3',
+        'ts-node': '^10.9.2',
+        nodemon: '^3.1.7',
+        'vitest': '^2.1.3',
+        '@vitest/ui': '^2.1.3',
+        'supertest': '^7.0.0',
+        '@types/supertest': '^6.0.2',
+        '@vitest/coverage-v8': '^2.1.3'
+    };
+    // Add database dependencies
+    if (config.storage === 'local-json') {
+        // No additional dependencies needed for JSON file storage
+    }
+    else if (config.storage === 'local-sqlite') {
+        if (config.databaseType === 'sql' && config.sqlOption === 'prisma') {
+            dependencies['@prisma/client'] = '^6.0.1';
+            devDependencies['prisma'] = '^6.0.1';
+        }
+        else if (config.databaseType === 'sql') {
+            dependencies['better-sqlite3'] = '^11.7.0';
+            devDependencies['@types/better-sqlite3'] = '^7.6.9';
+        }
+        else if (config.databaseType === 'nosql' && config.nosqlOption === 'mongodb') {
+            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';
+            devDependencies['prisma'] = '^6.0.1';
+        }
+        else if (config.databaseType === 'sql') {
+            dependencies['pg'] = '^8.13.1';
+            devDependencies['@types/pg'] = '^8.11.10';
+        }
+        else if (config.databaseType === 'nosql' && config.nosqlOption === 'mongodb') {
+            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['graphql'] = '^16.9.0';
+        dependencies['express-graphql'] = '^0.12.0';
+        devDependencies['@types/express-graphql'] = '^0.12.0';
+    }
+    const packageJson = {
+        name: `${config.projectName}-backend`,
+        version: '1.0.0',
+        main: 'dist/index.js',
+        scripts: {
+            dev: 'nodemon --exec ts-node src/index.ts',
+            build: 'tsc',
+            start: 'node dist/index.js',
+            test: 'vitest',
+            'test:ui': 'vitest --ui',
+            'test:coverage': 'vitest --coverage'
+        },
+        dependencies,
+        devDependencies
+    };
+    await fs_extra_1.default.writeJSON(path_1.default.join(backendPath, 'package.json'), packageJson, { spaces: 2 });
+    // Create TypeScript config
+    const tsconfig = {
+        compilerOptions: {
+            target: 'ES2020',
+            module: 'commonjs',
+            lib: ['ES2020'],
+            outDir: './dist',
+            rootDir: './src',
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true,
+            resolveJsonModule: true,
+            moduleResolution: 'node'
+        },
+        include: ['src/**/*'],
+        exclude: ['node_modules', 'dist']
+    };
+    await fs_extra_1.default.writeJSON(path_1.default.join(backendPath, 'tsconfig.json'), tsconfig, { spaces: 2 });
+    // Create Vitest config
+    const vitestConfig = `import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+    },
+  },
+})
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(backendPath, 'vitest.config.ts'), vitestConfig);
+    // Create src directory
+    const srcPath = path_1.default.join(backendPath, 'src');
+    await fs_extra_1.default.ensureDir(srcPath);
+    // Create index.ts
+    let indexContent = `import express from 'express';
+import cors from 'cors';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 3001;
+
+app.use(cors());
+app.use(express.json());
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+  res.json({ status: 'ok', message: 'Server is running' });
+});
+
+`;
+    if (config.apiType === 'graphql') {
+        indexContent += `import { graphqlHTTP } from 'express-graphql';
+import { buildSchema } from 'graphql';
+
+// GraphQL schema
+const schema = buildSchema(\`
+  type Query {
+    hello: String
+  }
+\`);
+
+// Root resolver
+const root = {
+  hello: () => 'Hello from GraphQL!',
+};
+
+app.use('/graphql', graphqlHTTP({
+  schema: schema,
+  rootValue: root,
+  graphiql: true,
+}));
+
+`;
+    }
+    else {
+        indexContent += `// REST API routes
+app.get('/api', (req, res) => {
+  res.json({ message: 'Welcome to the REST API' });
+});
+
+`;
+    }
+    indexContent += `const server = app.listen(PORT, () => {
+  console.log(\`Server is running on http://localhost:\${PORT}\`);
+});
+
+export default app;
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(srcPath, 'index.ts'), indexContent);
+    // 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 database setup if needed
+    if (config.storage === 'local-json') {
+        await generateJSONFileSetup(srcPath, config);
+    }
+    else if (config.databaseType === 'sql' && config.sqlOption === 'prisma') {
+        await generatePrismaConfig(backendPath, config);
+    }
+    else if (config.databaseType === 'sql' && config.storage === 'local-sqlite') {
+        await generateSQLiteSetup(srcPath, config);
+    }
+    else if (config.databaseType === 'nosql' && config.nosqlOption === 'mongodb') {
+        await generateMongoDBSetup(srcPath, config);
+    }
+    else if (config.databaseType === 'nosql' && config.nosqlOption === 'dynamodb') {
+        await generateDynamoDBSetup(srcPath, config);
+    }
+    // Create test files
+    const testPath = path_1.default.join(srcPath, '__tests__');
+    await fs_extra_1.default.ensureDir(testPath);
+    const testFile = `import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import request from 'supertest'
+import app from '../index'
+
+describe('API Tests', () => {
+  it('should return health check', async () => {
+    const res = await request(app).get('/health')
+    expect(res.status).toBe(200)
+    expect(res.body.status).toBe('ok')
+  })
+
+${config.apiType === 'rest' ? `  it('should return API welcome message', async () => {
+    const res = await request(app).get('/api')
+    expect(res.status).toBe(200)
+    expect(res.body.message).toContain('REST API')
+  })` : `  it('should handle GraphQL query', async () => {
+    const res = await request(app)
+      .post('/graphql')
+      .send({ query: '{ hello }' })
+    expect(res.status).toBe(200)
+    expect(res.body.data.hello).toBe('Hello from GraphQL!')
+  })`}
+})
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(testPath, 'api.test.ts'), testFile);
+    // Create deployment files
+    await generateBackendDeployment(backendPath, config);
+}
+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 start
+    envVars:
+      - key: NODE_ENV
+        value: production
+      - key: PORT
+        value: 3001
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(backendPath, 'render.yaml'), renderYaml);
+}
+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 generateSQLiteSetup(srcPath, config) {
+    const dbContent = `import Database from 'better-sqlite3';
+import path from 'path';
+
+const dbPath = path.join(process.cwd(), 'database.db');
+const db = new Database(dbPath);
+
+// Initialize database
+db.exec(\`
+  CREATE TABLE IF NOT EXISTS users (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    email TEXT UNIQUE NOT NULL,
+    name TEXT,
+    createdAt DATETIME DEFAULT CURRENT_TIMESTAMP
+  )
+\`);
+
+export default db;
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(srcPath, 'db.ts'), dbContent);
+}
+async function generateMongoDBSetup(srcPath, config) {
+    const dbContent = `import mongoose from 'mongoose';
+
+const connectDB = async () => {
+  try {
+    const mongoURI = process.env.DATABASE_URL || 'mongodb://localhost:27017/${config.projectName}';
+    await mongoose.connect(mongoURI);
+    console.log('MongoDB connected');
+  } catch (error) {
+    console.error('MongoDB connection error:', error);
+    process.exit(1);
+  }
+};
+
+// User schema example
+const userSchema = new mongoose.Schema({
+  email: { type: String, required: true, unique: true },
+  name: String,
+  createdAt: { type: Date, default: Date.now }
+});
+
+export const User = mongoose.model('User', userSchema);
+export default connectDB;
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(srcPath, 'db.ts'), dbContent);
+}
+async function generateDynamoDBSetup(srcPath, config) {
+    const dbContent = `import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
+
+const client = new DynamoDBClient({
+  region: process.env.AWS_REGION || 'us-east-1',
+});
+
+export const docClient = DynamoDBDocumentClient.from(client);
+
+export default docClient;
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(srcPath, 'db.ts'), dbContent);
+}
+async function generateJSONFileSetup(srcPath, config) {
+    const backendPath = path_1.default.dirname(path_1.default.dirname(srcPath));
+    const dbContent = `import fs from 'fs-extra';
+import path from 'path';
+
+const DB_FILE = path.join(process.cwd(), 'data', 'database.json');
+
+// Ensure data directory exists
+const dataDir = path.dirname(DB_FILE);
+fs.ensureDirSync(dataDir);
+
+// Initialize database file if it doesn't exist
+if (!fs.existsSync(DB_FILE)) {
+  fs.writeJSONSync(DB_FILE, { users: [] }, { spaces: 2 });
+}
+
+// Read database
+export const readDB = (): any => {
+  try {
+    return fs.readJSONSync(DB_FILE);
+  } catch (error) {
+    console.error('Error reading database:', error);
+    return { users: [] };
+  }
+};
+
+// Write database
+export const writeDB = (data: any): void => {
+  try {
+    fs.writeJSONSync(DB_FILE, data, { spaces: 2 });
+  } catch (error) {
+    console.error('Error writing database:', error);
+    throw error;
+  }
+};
+
+// Helper functions
+export const getUsers = () => {
+  const db = readDB();
+  return db.users || [];
+};
+
+export const addUser = (user: any) => {
+  const db = readDB();
+  if (!db.users) db.users = [];
+  const newUser = { ...user, id: db.users.length + 1, createdAt: new Date().toISOString() };
+  db.users.push(newUser);
+  writeDB(db);
+  return newUser;
+};
+
+export const getUserById = (id: number) => {
+  const db = readDB();
+  return db.users?.find((u: any) => u.id === id);
+};
+
+export const updateUser = (id: number, updates: any) => {
+  const db = readDB();
+  const userIndex = db.users?.findIndex((u: any) => u.id === id);
+  if (userIndex !== -1 && userIndex !== undefined) {
+    db.users[userIndex] = { ...db.users[userIndex], ...updates, updatedAt: new Date().toISOString() };
+    writeDB(db);
+    return db.users[userIndex];
+  }
+  return null;
+};
+
+export const deleteUser = (id: number) => {
+  const db = readDB();
+  db.users = db.users?.filter((u: any) => u.id !== id) || [];
+  writeDB(db);
+  return true;
+};
+
+export default { readDB, writeDB, getUsers, addUser, getUserById, updateUser, deleteUser };
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(srcPath, 'db.ts'), dbContent);
+    // Create initial data directory and file
+    const dataPath = path_1.default.join(backendPath, 'data');
+    await fs_extra_1.default.ensureDir(dataPath);
+    await fs_extra_1.default.writeJSON(path_1.default.join(dataPath, 'database.json'), { users: [] }, { spaces: 2 });
+}

package/dist/templates/backend/fastapi.js

@@ -0,0 +1,259 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFastAPI = generateFastAPI;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+async function generateFastAPI(backendPath, config) {
+    const dependencies = [
+        'fastapi==0.115.6',
+        'uvicorn[standard]==0.32.1',
+        'python-dotenv==1.0.1',
+        'pydantic==2.10.3',
+        'pydantic-settings==2.6.1'
+    ];
+    // Add database dependencies
+    if (config.storage === 'local-json') {
+        // No additional dependencies needed for JSON file storage (uses built-in json module)
+    }
+    else if (config.storage === 'local-sqlite') {
+        if (config.databaseType === 'sql') {
+            dependencies.push('sqlalchemy==2.0.36');
+        }
+        else if (config.databaseType === 'nosql' && config.nosqlOption === 'mongodb') {
+            dependencies.push('motor==3.6.0');
+            dependencies.push('pymongo==4.10.1');
+        }
+    }
+    else if (config.storage === 'external-url') {
+        if (config.databaseType === 'sql') {
+            dependencies.push('sqlalchemy==2.0.36');
+            dependencies.push('psycopg2-binary==2.9.10');
+        }
+        else if (config.databaseType === 'nosql' && config.nosqlOption === 'mongodb') {
+            dependencies.push('motor==3.6.0');
+            dependencies.push('pymongo==4.10.1');
+        }
+        else if (config.databaseType === 'nosql' && config.nosqlOption === 'dynamodb') {
+            dependencies.push('boto3==1.35.47');
+        }
+    }
+    // Create requirements.txt
+    await fs_extra_1.default.writeFile(path_1.default.join(backendPath, 'requirements.txt'), dependencies.join('\n'));
+    // Create main.py
+    const srcPath = path_1.default.join(backendPath, 'src');
+    await fs_extra_1.default.ensureDir(srcPath);
+    let mainContent = `from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+app = FastAPI(title="${config.projectName} API")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/")
+def read_root():
+    return {"message": "Welcome to ${config.projectName} API"}
+
+@app.get("/health")
+def health_check():
+    return {"status": "ok", "message": "Server is running"}
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", 3001))
+    uvicorn.run(app, host="0.0.0.0", port=port)
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(srcPath, 'main.py'), mainContent);
+    // 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 database setup if needed
+    if (config.storage === 'local-json') {
+        await generateJSONFileSetup(srcPath, config);
+    }
+    else if (config.databaseType === 'sql') {
+        await generateSQLAlchemySetup(srcPath, config);
+    }
+    else if (config.databaseType === 'nosql' && config.nosqlOption === 'mongodb') {
+        await generateMongoDBSetup(srcPath, config);
+    }
+    else if (config.databaseType === 'nosql' && config.nosqlOption === 'dynamodb') {
+        await generateDynamoDBSetup(srcPath, config);
+    }
+    // Create deployment files
+    await generateBackendDeployment(backendPath, config);
+}
+async function generateBackendDeployment(backendPath, config) {
+    // Render configuration
+    const renderYaml = `services:
+  - type: web
+    name: ${config.projectName}-backend
+    env: python
+    buildCommand: pip install -r requirements.txt
+    startCommand: uvicorn src.main:app --host 0.0.0.0 --port \$PORT
+    envVars:
+      - key: PORT
+        value: 3001
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(backendPath, 'render.yaml'), renderYaml);
+}
+async function generateSQLAlchemySetup(srcPath, config) {
+    const dbUrlLine = config.storage === 'local-sqlite'
+        ? 'DATABASE_URL = "sqlite:///./database.db"'
+        : 'DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://user:password@localhost/dbname")';
+    const dbContent = `from sqlalchemy import create_engine, Column, Integer, String, DateTime
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+import os
+from datetime import datetime
+
+${dbUrlLine}
+
+engine = create_engine(DATABASE_URL)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+class User(Base):
+    __tablename__ = "users"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(String, unique=True, index=True)
+    name = Column(String, nullable=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+Base.metadata.create_all(bind=engine)
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(srcPath, 'database.py'), dbContent);
+}
+async function generateMongoDBSetup(srcPath, config) {
+    const dbContent = `from motor.motor_asyncio import AsyncIOMotorClient
+import os
+
+DATABASE_URL = os.getenv("DATABASE_URL", "mongodb://localhost:27017")
+DATABASE_NAME = "${config.projectName}"
+
+client = AsyncIOMotorClient(DATABASE_URL)
+db = client[DATABASE_NAME]
+
+# Collections
+users_collection = db["users"]
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(srcPath, 'database.py'), dbContent);
+}
+async function generateDynamoDBSetup(srcPath, config) {
+    const dbContent = `import boto3
+import os
+
+dynamodb = boto3.resource(
+    'dynamodb',
+    region_name=os.getenv('AWS_REGION', 'us-east-1')
+)
+
+# Table references
+users_table = dynamodb.Table('users')
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(srcPath, 'database.py'), dbContent);
+}
+async function generateJSONFileSetup(srcPath, config) {
+    const backendPath = path_1.default.dirname(path_1.default.dirname(srcPath));
+    const dbContent = `import json
+import os
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+
+DB_FILE = Path(__file__).parent.parent / 'data' / 'database.json'
+
+# Ensure data directory exists
+DB_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+# Initialize database file if it doesn't exist
+if not DB_FILE.exists():
+    with open(DB_FILE, 'w') as f:
+        json.dump({'users': []}, f, indent=2)
+
+def read_db() -> Dict[str, Any]:
+    """Read the database from JSON file."""
+    try:
+        with open(DB_FILE, 'r') as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        return {'users': []}
+
+def write_db(data: Dict[str, Any]) -> None:
+    """Write data to the database JSON file."""
+    with open(DB_FILE, 'w') as f:
+        json.dump(data, f, indent=2)
+
+def get_users() -> List[Dict[str, Any]]:
+    """Get all users from the database."""
+    db = read_db()
+    return db.get('users', [])
+
+def add_user(user: Dict[str, Any]) -> Dict[str, Any]:
+    """Add a new user to the database."""
+    db = read_db()
+    users = db.get('users', [])
+    new_user = {
+        **user,
+        'id': len(users) + 1,
+        'created_at': str(Path(__file__).stat().st_mtime)
+    }
+    users.append(new_user)
+    db['users'] = users
+    write_db(db)
+    return new_user
+
+def get_user_by_id(user_id: int) -> Optional[Dict[str, Any]]:
+    """Get a user by ID."""
+    users = get_users()
+    return next((u for u in users if u.get('id') == user_id), None)
+
+def update_user(user_id: int, updates: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Update a user by ID."""
+    db = read_db()
+    users = db.get('users', [])
+    for i, user in enumerate(users):
+        if user.get('id') == user_id:
+            users[i] = {**user, **updates, 'updated_at': str(Path(__file__).stat().st_mtime)}
+            db['users'] = users
+            write_db(db)
+            return users[i]
+    return None
+
+def delete_user(user_id: int) -> bool:
+    """Delete a user by ID."""
+    db = read_db()
+    users = db.get('users', [])
+    db['users'] = [u for u in users if u.get('id') != user_id]
+    write_db(db)
+    return True
+`;
+    await fs_extra_1.default.writeFile(path_1.default.join(srcPath, 'database.py'), dbContent);
+    // Create initial data directory and file
+    const dataPath = path_1.default.join(backendPath, 'data');
+    await fs_extra_1.default.ensureDir(dataPath);
+    await fs_extra_1.default.writeJSON(path_1.default.join(dataPath, 'database.json'), { users: [] }, { spaces: 2 });
+}