@shivasankaran18/stackd 1.1.0 → 1.2.0

package/dist/apps/cli/src/scripts/Auth/passport.js

@@ -0,0 +1,218 @@
+import { join } from 'node:path';
+import { mkdir, writeFile } from 'node:fs/promises';
+export async function setupPassport(config, projectDir, emitLog) {
+    emitLog('Setting up Passport...');
+    try {
+        const backendDir = join(projectDir, 'backend');
+        const authDir = join(backendDir, 'src', 'auth');
+        const configDir = join(backendDir, 'src', 'config');
+        emitLog('Creating auth and config directories...');
+        await mkdir(authDir, { recursive: true });
+        await mkdir(configDir, { recursive: true });
+        const passportConfigCode = `
+import passport from 'passport';
+import { Strategy as LocalStrategy } from 'passport-local';
+import { Strategy as JwtStrategy, ExtractJwt } from 'passport-jwt';
+import { Strategy as GoogleStrategy } from 'passport-google-oauth20';
+import { User } from '../models/user.model';
+import { config } from '../config';
+
+// Local Strategy
+passport.use(new LocalStrategy(
+    { usernameField: 'email' },
+    async (email, password, done) => {
+        try {
+            const user = await User.findOne({ email });
+            if (!user) {
+                return done(null, false, { message: 'Incorrect email.' });
+            }
+            
+            const isValid = await user.comparePassword(password);
+            if (!isValid) {
+                return done(null, false, { message: 'Incorrect password.' });
+            }
+            
+            return done(null, user);
+        } catch (error) {
+            return done(error);
+        }
+    }
+));
+
+// JWT Strategy
+passport.use(new JwtStrategy(
+    {
+        jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+        secretOrKey: config.jwt.secret,
+    },
+    async (payload, done) => {
+        try {
+            const user = await User.findById(payload.sub);
+            if (!user) {
+                return done(null, false);
+            }
+            return done(null, user);
+        } catch (error) {
+            return done(error, false);
+        }
+    }
+));
+
+// Google OAuth Strategy
+passport.use(new GoogleStrategy(
+    {
+        clientID: config.google.clientId,
+        clientSecret: config.google.clientSecret,
+        callbackURL: '/auth/google/callback',
+    },
+    async (accessToken, refreshToken, profile, done) => {
+        try {
+            let user = await User.findOne({ googleId: profile.id });
+            
+            if (!user) {
+                user = await User.create({
+                    googleId: profile.id,
+                    email: profile.emails?.[0]?.value,
+                    name: profile.displayName,
+                });
+            }
+            
+            return done(null, user);
+        } catch (error) {
+            return done(error, false);
+        }
+    }
+));
+
+// Serialization
+passport.serializeUser((user: any, done) => {
+    done(null, user.id);
+});
+
+passport.deserializeUser(async (id: string, done) => {
+    try {
+        const user = await User.findById(id);
+        done(null, user);
+    } catch (error) {
+        done(error);
+    }
+});
+
+export default passport;
+`;
+        emitLog('Writing passport.config.ts...');
+        await writeFile(join(authDir, 'passport.config.ts'), passportConfigCode.trim() + '\n');
+        emitLog('Creating authentication middleware...');
+        const authMiddlewareCode = `
+import { Request, Response, NextFunction } from 'express';
+import passport from 'passport';
+import jwt from 'jsonwebtoken';
+import { config } from '../config';
+
+export const authenticateJWT = passport.authenticate('jwt', { session: false });
+
+export const authenticateLocal = (req: Request, res: Response, next: NextFunction) => {
+    passport.authenticate('local', { session: false }, (err, user, info) => {
+        if (err) {
+            return next(err);
+        }
+        if (!user) {
+            return res.status(401).json({ message: info?.message || 'Authentication failed' });
+        }
+        
+        const token = jwt.sign({ sub: user.id }, config.jwt.secret, {
+            expiresIn: config.jwt.expiresIn,
+        });
+        
+        req.user = user;
+        res.locals.token = token;
+        next();
+    })(req, res, next);
+};
+
+export const isAuthenticated = (req: Request, res: Response, next: NextFunction) => {
+    if (req.isAuthenticated()) {
+        return next();
+    }
+    res.status(401).json({ message: 'Unauthorized' });
+};
+`;
+        emitLog('Writing middleware.ts...');
+        await writeFile(join(authDir, 'middleware.ts'), authMiddlewareCode.trim() + '\n');
+        emitLog('Creating authentication routes...');
+        const authRoutesCode = `
+import { Router } from 'express';
+import passport from 'passport';
+import { authenticateLocal } from './middleware';
+
+const router = Router();
+
+router.post('/login', authenticateLocal, (req, res) => {
+    res.json({
+        user: req.user,
+        token: res.locals.token,
+    });
+});
+
+router.post('/register', async (req, res) => {
+    // Add your registration logic here
+});
+
+router.get('/google',
+    passport.authenticate('google', { scope: ['profile', 'email'] })
+);
+
+router.get('/google/callback',
+    passport.authenticate('google', { session: false }),
+    (req, res) => {
+        // Handle successful authentication
+        res.redirect('/');
+    }
+);
+
+router.post('/logout', (req, res) => {
+    req.logout();
+    res.json({ message: 'Logged out successfully' });
+});
+
+export default router;
+`;
+        emitLog('Writing routes.ts...');
+        await writeFile(join(authDir, 'routes.ts'), authRoutesCode.trim() + '\n');
+        emitLog('Creating configuration file...');
+        const configCode = `
+export const config = {
+    jwt: {
+        secret: process.env.JWT_SECRET || 'your-secret-key',
+        expiresIn: '1d',
+    },
+    google: {
+        clientId: process.env.GOOGLE_CLIENT_ID,
+        clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+    },
+    session: {
+        secret: process.env.SESSION_SECRET || 'session-secret',
+    },
+};
+`;
+        emitLog('Writing index.ts...');
+        await writeFile(join(configDir, 'index.ts'), configCode.trim() + '\n');
+        emitLog('Adding environment variables...');
+        const envContent = `
+# Authentication
+JWT_SECRET=your-jwt-secret-key
+SESSION_SECRET=your-session-secret
+
+# Google OAuth
+GOOGLE_CLIENT_ID=your-google-client-id
+GOOGLE_CLIENT_SECRET=your-google-client-secret
+`;
+        emitLog('Writing .env file...');
+        await writeFile(join(backendDir, '.env'), envContent.trim() + '\n');
+        emitLog('✅ Passport.js setup completed successfully!');
+    }
+    catch (error) {
+        emitLog(`❌ Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw error;
+    }
+}

package/dist/apps/cli/src/scripts/backend/django.js

@@ -0,0 +1,20 @@
+import { exec } from 'child_process';
+import { mkdirSync } from 'fs';
+import util from 'util';
+const execAsync = util.promisify(exec);
+export async function installDjangoDependencies(projectPath) {
+    try {
+        mkdirSync(`${projectPath}/backend`, { recursive: true });
+        await execAsync('python -m venv venv', { cwd: `${projectPath}/backend` });
+        const pythonCmd = process.platform === 'win32' ? 'venv\\Scripts\\python.exe' : 'venv/bin/python';
+        await execAsync(`${pythonCmd} -m pip install django djangorestframework django-cors-headers djangorestframework_simplejwt`, { cwd: `${projectPath}/backend` });
+        await execAsync(`${pythonCmd} -m django startproject core .`, { cwd: `${projectPath}/backend` });
+        await execAsync(`${pythonCmd} manage.py startapp main`, { cwd: `${projectPath}/backend` });
+        console.log("Django project setup completed!");
+    }
+    catch (error) {
+        console.error('Error installing Django dependencies:', error);
+        throw error;
+    }
+}
+export default installDjangoDependencies;

package/dist/apps/cli/src/scripts/backend/expressjs.js

@@ -0,0 +1,58 @@
+import { execSync } from 'node:child_process';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+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/dist/apps/cli/src/scripts/backend/expressts.js

@@ -0,0 +1,83 @@
+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/dist/apps/cli/src/scripts/frontend/angularjs.js

@@ -0,0 +1 @@
+export {};

package/dist/apps/cli/src/scripts/frontend/angularts.js

@@ -0,0 +1,22 @@
+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/dist/apps/cli/src/scripts/frontend/nextjs.js

@@ -0,0 +1,62 @@
+// import { join } from 'node:path'
+// import { execSync, ExecSyncOptions } from 'child_process'
+// import { writeFile, mkdir } from 'node:fs/promises'
+// import { existsSync } from 'fs'
+export {};
+// export async function createNextJS(config: any, projectDir: string, emitLog: (log: string) => void) {
+//     try {
+//         const frontendDir = join(projectDir, 'frontend');
+//         if (!existsSync(frontendDir)) {
+//             emitLog('Creating frontend directory...');
+//             await mkdir(frontendDir, { recursive: true });
+//         }
+//         emitLog('Creating Next.js project...');
+//         const execOptions: ExecSyncOptions = {
+//             cwd: frontendDir,
+//             stdio: 'inherit',
+//             encoding: 'utf-8'
+//         };
+//         execSync('npx create-next-app@latest . --typescript --tailwind --eslint --app --src-dir --import-alias "@/*" --no-git', execOptions);
+//         emitLog('Updating package.json...');
+//         const packageJsonPath = join(frontendDir, 'package.json');
+//         const packageJson = require(packageJsonPath);
+//         packageJson.scripts.dev = `next dev -p ${config.frontendPort}`;
+//         await writeFile(
+//             packageJsonPath,
+//             JSON.stringify(packageJson, null, 2)
+//         );
+//         emitLog('Creating environment file...');
+//         const envContent = `
+// NEXT_PUBLIC_API_URL=http://localhost:${config.backendPort}
+// NEXTAUTH_URL=http://localhost:${config.frontendPort}
+// NEXTAUTH_SECRET=your-secret-key-here
+// `;
+//         await writeFile(
+//             join(frontendDir, '.env'),
+//             envContent.trim() + '\n'
+//         );
+//         emitLog('Setting up API proxy...');
+//         const nextConfigContent = `
+// /** @type {import('next').NextConfig} */
+// const nextConfig = {
+//     async rewrites() {
+//         return [
+//             {
+//                 source: '/api/:path*',
+//                 destination: 'http://localhost:${config.backendPort}/api/:path*'
+//             }
+//         ]
+//     }
+// }
+// module.exports = nextConfig
+// `;
+//         await writeFile(
+//             join(frontendDir, 'next.config.js'),
+//             nextConfigContent.trim() + '\n'
+//         );
+//         emitLog('✅ Next.js setup completed successfully!');
+//     } catch (error) {
+//         emitLog(`❌ Error setting up Next.js: ${error instanceof Error ? error.message : 'Unknown error'}`);
+//         throw error;
+//     }
+// }

package/dist/apps/cli/src/scripts/frontend/reactjs.js

@@ -0,0 +1,31 @@
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+export async function createReactJS(config, projectDir, emitLog) {
+    emitLog('Creating ReactJS project...');
+    await execSync(`npm create vite@latest frontend -- --template react`, {
+        cwd: projectDir,
+        stdio: 'inherit'
+    });
+    emitLog('Installing the dependencies for the frontend...');
+    await execSync("npm install", { cwd: projectDir + "/frontend", stdio: "inherit" });
+    emitLog('Writing Vite configuration...');
+    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());
+    emitLog('✅ ReactJS project created successfully!');
+}

package/dist/apps/cli/src/scripts/frontend/reactts.js

@@ -0,0 +1,30 @@
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+export async function createReactTS(config, projectDir, emitLog) {
+    emitLog('Creating ReactTS project...');
+    await execSync(`npm create vite@latest frontend -- --template react-ts`, {
+        cwd: projectDir,
+        stdio: 'inherit'
+    });
+    emitLog('Installing the dependencies...');
+    await execSync('npm install', { cwd: projectDir + '/frontend', stdio: 'inherit' });
+    emitLog('Writing Vite configuration...');
+    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());
+    emitLog('✅ ReactTS project created successfully!');
+}

package/dist/apps/cli/src/scripts/frontend/vuejs.js

@@ -0,0 +1,37 @@
+import { 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/dist/apps/cli/src/scripts/frontend/vuets.js

@@ -0,0 +1,43 @@
+import { 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!');
+}