@shivasankaran18/stackd 2.0.2 → 13.0.0

package/apps/cli/src/generators/backend/expressjs.js

@@ -0,0 +1,72 @@
+import { execSync } from 'node:child_process'
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { writeFileSync } from 'fs'
+
+export async function createExpressJS(config, projectDir,emitLog) {
+    emitLog('Creating ExpressJS project...');
+    await mkdir(join(projectDir, 'backend'))
+    const backendPackageJson = {
+        name: "backend",
+        version: "1.0.0",
+        scripts: {
+            "dev": "nodemon src/index.js",
+            "start": "node src/index.js"
+        },
+        dependencies: {
+            "express": "^4.18.2",
+            "cors": "^2.8.5",
+            "dotenv": "^16.3.1"
+        },
+        devDependencies: {
+            "nodemon": "^2.0.22"
+        }
+    }
+
+    emitLog('Writing package.json...');
+    await writeFile(
+        join(projectDir, 'backend', 'package.json'),
+        JSON.stringify(backendPackageJson, null, 2)
+    )
+
+    emitLog('Creating src directory...');
+    await mkdir(join(projectDir, 'backend', 'src'))
+
+    const backendIndex = `
+const express = require('express');
+const cors = require('cors');
+const dotenv = require('dotenv');
+
+dotenv.config();
+
+const app = express();
+const port = process.env.PORT || ${config.backendPort};
+
+app.use(cors());
+app.use(express.json());
+
+// Test route
+app.get('/api/test', (req, res) => {
+    res.json({ message: 'Hello from Express!' });
+});
+
+// Health check route
+app.get('/api/health', (req, res) => {
+    res.json({ status: 'ok', timestamp: new Date() });
+});
+
+app.listen(port, () => {
+    console.log(\`Server running on port \${port}\`);
+});`
+
+    emitLog('Writing index.js...');
+    await writeFile(
+        join(projectDir, 'backend', 'src', 'index.js'),
+        backendIndex.trim()
+    )
+    
+    emitLog('Installing dependencies...');
+    await execSync("npm install",{cwd : projectDir + '/backend',stdio : "inherit"});
+
+    emitLog('✅ ExpressJS project created successfully!');
+} 

package/apps/cli/src/generators/backend/expressts.js

@@ -0,0 +1,95 @@
+import { execSync } from 'node:child_process'
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+export async function createExpressTS(config, projectDir ,emitLog) {
+    emitLog('Creating ExpressTS project...');
+    await mkdir(join(projectDir, 'backend'));
+    emitLog('Writing package.json...');
+    const backendPackageJson = {
+        name: "backend",
+        version: "1.0.0",
+        scripts: {
+            "dev": "ts-node-dev --respawn --transpile-only src/index.ts",
+            "build": "tsc",
+            "start": "node dist/index.js"
+        },
+        dependencies: {
+            "express": "^4.18.2",
+            "cors": "^2.8.5",
+            "dotenv": "^16.3.1"
+        },
+        devDependencies: {
+            "@types/express": "^4.17.17",
+            "@types/cors": "^2.8.13",
+            "@types/node": "^20.4.5",
+            "typescript": "^5.1.6",
+            "ts-node-dev": "^2.0.0"
+        }
+    }
+
+    await writeFile(
+        join(projectDir, 'backend', 'package.json'),
+        JSON.stringify(backendPackageJson, null, 2)
+    )
+    emitLog('Writing tsconfig.json...');
+    const tsConfig = {
+        compilerOptions: {
+            "target": "ES2020",
+            "module": "CommonJS",
+            "lib": ["ES2020"],
+            "moduleResolution": "node",
+            "outDir": "./dist",
+            "rootDir": "./src",
+            "strict": true,
+            "esModuleInterop": true,
+            "skipLibCheck": true,
+            "forceConsistentCasingInFileNames": true,
+            "resolveJsonModule": true
+        },
+        include: ["src/**/*"],
+        exclude: ["node_modules"]
+    }
+
+    await writeFile(
+        join(projectDir, 'backend', 'tsconfig.json'),
+        JSON.stringify(tsConfig, null, 2)
+    )
+    emitLog('Creating src directory...');
+    await mkdir(join(projectDir, 'backend', 'src'))
+    emitLog('Writing index.ts...');
+    const backendIndex = `
+import express from 'express';
+import cors from 'cors';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const app = express();
+const port = process.env.PORT || ${config.backendPort};
+
+app.use(cors());
+app.use(express.json());
+
+// Test route
+app.get('/api/test', (req, res) => {
+    res.json({ message: 'Hello from Express!' });
+});
+
+// Health check route
+app.get('/api/health', (req, res) => {
+    res.json({ status: 'ok', timestamp: new Date() });
+});
+
+app.listen(port, () => {
+    console.log(\`Server running on port \${port}\`);
+});`
+    emitLog('Writing index.ts...');     
+    await writeFile(
+        join(projectDir, 'backend', 'src', 'index.ts'),
+        backendIndex.trim()
+    )
+    emitLog('Installing dependencies...');
+    await execSync("npm install",{cwd : projectDir + '/backend',stdio : "inherit"});
+    emitLog('✅ ExpressTS project created successfully!');
+}

package/apps/cli/src/generators/frontend/angularts.js

@@ -0,0 +1,29 @@
+import { execSync } from "child_process";
+import path from "path";
+
+export default async function createAngularTS(config, projectDir) {
+    try {
+
+        const projectFullPath = path.join(projectDir, 'frontend');
+
+        console.log('Installing Angular CLI...');
+        await execSync(`npx @angular/cli@latest new frontend --skip-git --style=scss --routing=true --strict`, {
+            cwd: projectDir,
+            stdio: 'inherit'
+        });
+
+       
+        console.log('Installing dependencies...');
+        await execSync('npm install', {
+            cwd: projectFullPath,
+            stdio: 'inherit'
+        });
+
+        console.log('Angular project created successfully!');
+        
+    } catch (error) {
+        console.error('Error creating Angular project:', error);
+        throw error;
+    }
+}
+

package/apps/cli/src/generators/frontend/reactjs.js

@@ -0,0 +1,42 @@
+import { mkdir, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { execSync } from 'child_process';
+
+export async function createReactJS(config, projectDir,emitLog) {
+    emitLog("Creating React JavaScript frontend...");
+    
+    await execSync(`npm create vite@latest frontend -- --template react`, {
+        cwd: projectDir,
+      stdio: 'inherit',
+        shell: true
+    });
+
+    emitLog("Installing dependencies...");
+    await execSync('npm install', {
+        cwd: join(projectDir, 'frontend'),
+        stdio: 'inherit',
+        shell: true
+    });
+
+    const viteConfig = `
+    import { defineConfig } from 'vite'
+    import react from '@vitejs/plugin-react'
+    
+    export default defineConfig({
+      plugins: [react()],
+      server: {
+        port: ${config.frontendPort},
+        proxy: {
+          '/api': {
+            target: 'http://localhost:${config.backendPort}',
+            changeOrigin: true
+          }
+        }
+      }
+    })`;
+
+    await writeFile(
+        join(projectDir, 'frontend', 'vite.config.js'),
+        viteConfig.trim()
+    );
+}

package/apps/cli/src/generators/frontend/reactts.d.ts

@@ -0,0 +1,13 @@
+export interface ProjectConfig {
+  projectName: string;
+  projectPath: string;
+  frontendPort: number;
+  backendPort: number;
+  dbUrl: string;
+}
+
+export function createReactTS(
+  config: ProjectConfig, 
+  projectDir: string, 
+  emitLog: (message: string) => void
+): Promise<void>; 

package/apps/cli/src/generators/frontend/reactts.js

@@ -0,0 +1,40 @@
+import {  writeFile } from 'fs/promises';
+import { join } from 'path';
+import { execSync } from 'child_process';
+
+export async function createReactTS(config, projectDir,emitLog) {
+    emitLog("Creating React TypeScript frontend...");
+    
+    await execSync(`npm create vite@latest frontend -- --template react-ts`, {
+        cwd: projectDir,
+        stdio: 'inherit'
+    });
+
+    emitLog("Installing dependencies...");
+    await execSync('npm install', {
+        cwd: join(projectDir, 'frontend'),
+        stdio: 'inherit'
+    });
+
+    const viteConfig = `
+    import { defineConfig } from 'vite'
+    import react from '@vitejs/plugin-react'
+    
+    export default defineConfig({
+      plugins: [react()],
+      server: {
+        port: ${config.frontendPort},
+        proxy: {
+          '/api': {
+            target: 'http://localhost:${config.backendPort}',
+            changeOrigin: true
+          }
+        }
+      }
+    })`;
+
+    await writeFile(
+        join(projectDir, 'frontend', 'vite.config.ts'),
+        viteConfig.trim()
+    );
+}

package/apps/cli/src/generators/frontend/vuejs.js

@@ -0,0 +1,43 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { execSync } from 'node:child_process'
+
+export async function createVueJS(config, projectDir,emitLog) {
+    emitLog('Creating VueJS project...');
+    await execSync(`npm create vite@latest frontend -- --template vue`, {
+        cwd: projectDir,
+        stdio: 'inherit'
+    })
+
+    emitLog('Installing Vite...');
+    console.log(projectDir)
+    console.log(config)
+    const viteConfig = `
+    import { defineConfig } from 'vite'
+    import vue from '@vitejs/plugin-vue'
+    
+    export default defineConfig({
+      plugins: [vue()],
+      server: {
+        port: ${config.frontendPort},
+        proxy: {
+          '/api': {
+            target: 'http://localhost:${config.backendPort}',
+            changeOrigin: true
+          }
+        }
+      }
+    })`
+
+    emitLog('Writing Vite configuration...');
+    await writeFile(
+        join(projectDir, 'frontend', `vite.config.js`),
+        viteConfig.trim()
+    )
+    emitLog('Installing Vue Router and Pinia...');
+    await execSync('npm install vue-router@4 pinia@2', {
+        cwd: join(projectDir, 'frontend'),
+        stdio: 'inherit'
+    })
+    emitLog('✅ VueJS project created successfully!');
+}

package/apps/cli/src/generators/frontend/vuets.js

@@ -0,0 +1,53 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { execSync } from 'node:child_process'
+
+export async function createVueTS(config, projectDir,emitLog) {
+    emitLog('Creating VueTS project...');
+
+    emitLog('Installing Vite...');  
+    await execSync(`npm create vite@latest frontend -- --template vue-ts`, {
+        cwd: projectDir,
+        stdio: 'inherit'
+    })
+
+    emitLog('Configuring Vite...');
+    const viteConfig = `
+    import { defineConfig } from 'vite'
+    import vue from '@vitejs/plugin-vue'
+    
+    export default defineConfig({
+      plugins: [vue()],
+      server: {
+        port: ${config.frontendPort},
+        proxy: {
+          '/api': {
+            target: 'http://localhost:${config.backendPort}',
+            changeOrigin: true
+          }
+        }
+      }
+    })`
+
+    emitLog('Writing Vite configuration...');
+    await writeFile(
+        join(projectDir, 'frontend', `vite.config.ts`),
+        viteConfig.trim()
+    )
+
+    emitLog('Installing Vue Router and Pinia...');
+    await execSync('npm install vue-router@4 pinia@2', {
+        cwd: join(projectDir, 'frontend'),
+        stdio: 'inherit'
+    })
+
+    emitLog('Installing TypeScript and other dependencies...');
+    if (config.frontend === 'vue-ts') {
+        await execSync('npm install -D @types/node', {
+            cwd: join(projectDir, 'frontend'),
+            stdio: 'inherit'
+        })
+    }
+
+    emitLog('✅ VueTS project created successfully!');
+}

package/apps/cli/src/generators/orm/drizzleSetup.js

@@ -0,0 +1,102 @@
+import { join } from 'node:path'
+import { mkdir, writeFile } from 'node:fs/promises'
+import 'dotenv/config'
+
+export async function setupDrizzle(config, projectDir, emitLog) {
+    try {
+        emitLog('Starting Drizzle ORM setup...');
+        const backendDir = join(projectDir, 'backend');
+        const dbDir = join(backendDir, 'src', 'db');
+        const schemasDir = join(dbDir, 'schema');
+        emitLog('Creating directory structure...');
+        await mkdir(schemasDir, { recursive: true });
+        emitLog('✅ Directory structure created');
+
+        emitLog('Generating environment configuration...');
+        const envContent = `
+# Database Configuration
+${config.env?.DATABASE_URL_ENV || 'DATABASE_URL'}=postgres://user:password@localhost:5432/${config.databaseName || 'myapp'}
+# Add other environment variables here
+NODE_ENV=development
+PORT=3000
+`;
+        await writeFile(
+            join(backendDir, '.env'),
+            envContent.trim() + '\n'
+        );
+        emitLog('✅ Environment configuration created');
+
+        emitLog('Setting up database connection...');
+        const dbCode = `
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { Pool } from 'pg';
+import 'dotenv/config';
+
+const pool = new Pool({
+    connectionString: process.env.${config.env?.DATABASE_URL_ENV || 'DATABASE_URL'},
+});
+
+export const db = drizzle(pool);
+
+export async function connectDB() {
+    try {
+        await pool.connect();
+        console.log('Connected to PostgreSQL database');
+    } catch (error) {
+        console.error('Database connection error:', error);
+        process.exit(1);
+    }
+}
+
+export async function disconnectDB() {
+    await pool.end();
+    console.log('Disconnected from PostgreSQL database');
+}
+`;
+        await writeFile(
+            join(dbDir, 'index.ts'),
+            dbCode
+        );
+        emitLog('✅ Database connection setup complete');
+
+        emitLog('Creating example schema...');
+        const exampleSchemaCode = `
+import { pgTable, serial, varchar, timestamp } from 'drizzle-orm/pg-core';
+
+export const examples = pgTable('examples', {
+    id: serial('id').primaryKey(),
+    name: varchar('name', { length: 256 }).notNull(),
+    createdAt: timestamp('created_at').defaultNow(),
+});
+`;
+        await writeFile(
+            join(schemasDir, 'example.ts'),
+            exampleSchemaCode
+        );
+        emitLog('✅ Example schema created');
+
+        emitLog('Configuring Drizzle migrations...');
+        const drizzleConfigCode = `
+import type { Config } from 'drizzle-kit';
+
+export default {
+    schema: './src/db/schema/*',
+    out: './src/db/migrations',
+    driver: 'pg',
+    dbCredentials: {
+        connectionString: process.env.${config.env?.DATABASE_URL_ENV || 'DATABASE_URL'}!,
+    },
+} satisfies Config;
+`;
+        await writeFile(
+            join(backendDir, 'drizzle.config.ts'),
+            drizzleConfigCode
+        );
+        emitLog('✅ Drizzle configuration complete');
+
+        emitLog('✅ Drizzle ORM setup completed successfully!');
+    } catch (error) {
+        emitLog(`❌ Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw error;
+    }
+}

package/apps/cli/src/generators/orm/mongoSetup.js

@@ -0,0 +1,68 @@
+import { join } from 'node:path'
+import { mkdir, writeFile } from 'node:fs/promises'
+import 'dotenv/config'
+
+export async function setupMongoose(config, projectDir,emitLog) {
+    const backendDir = join(projectDir, 'backend');
+    const modelsDir = join(backendDir, 'src', 'models');
+    await mkdir(modelsDir, { recursive: true });
+
+    emitLog('Generating environment configuration...');
+    const envContent = `
+# MongoDB Configuration
+${config.env?.MONGODB_URI_ENV || 'MONGODB_URI'}=mongodb://localhost:27017/${config.databaseName || 'myapp'}
+
+# Add other environment variables here
+NODE_ENV=development
+PORT=3000
+`;
+
+    await writeFile(
+        join(backendDir, '.env'),
+        envContent.trim() + '\n'
+    );
+    emitLog('✅ Environment configuration created');
+
+    emitLog('Setting up database connection...');
+    const dbCode = `
+import mongoose from 'mongoose';
+
+const MONGODB_URI = process.env.${config.env?.MONGODB_URI_ENV || 'MONGODB_URI'} || 'mongodb://localhost:27017/${config.databaseName || 'myapp'}';
+
+export async function connectDB() {
+    try {
+        await mongoose.connect(MONGODB_URI);
+        console.log('Connected to MongoDB');
+    } catch (error) {
+        console.error('MongoDB connection error:', error);
+        process.exit(1);
+    }
+}
+    
+export async function disconnectDB() {
+    await mongoose.disconnect();
+    console.log('Disconnected from MongoDB');
+}
+`;
+    emitLog('✅ Database connection setup complete');
+    await writeFile(
+        join(backendDir, 'db.ts'),
+        dbCode
+    );
+
+    const exampleModelCode = `
+import mongoose from 'mongoose';
+
+const exampleSchema = new mongoose.Schema({
+    name: { type: String, required: true },
+    createdAt: { type: Date, default: Date.now },
+});
+
+export const Example = mongoose.model('Example', exampleSchema);
+`;
+
+    await writeFile(
+        join(modelsDir, 'example.ts'),
+        exampleModelCode
+    );
+}

package/apps/cli/src/generators/orm/prismaSetup.js

@@ -0,0 +1,14 @@
+import { join } from 'node:path'
+import { execSync } from 'node:child_process'
+import { writeFileSync } from 'node:fs';
+
+
+export async function setupPrisma(config, projectDir,emitLog) {
+    emitLog('Setting up Prisma...');
+    const backendDir = join(projectDir, 'backend');
+    const envContent = `DATABASE_URL=${config.dbUrl}\n`;
+    writeFileSync(join(projectDir, 'backend', '.env'), envContent);
+    await execSync('npm install prisma', { cwd: backendDir });
+    await execSync('npx prisma init', { cwd: backendDir });
+    emitLog('✅ Prisma setup complete');
+}