@shivasankaran18/stackd 2.0.2 → 13.0.0

package/README.md

@@ -14,7 +14,7 @@ STACKD (Abbreviation TBD) is an open-source scaffolding tool that simplifies the
 
 ## 💡 Motivation
 
-Every time my team and I participated in a hackathon, we found ourselves spending a significant amount of time setting up the project’s basic structure—configuring the frontend, backend, database, authentication, and other essential components. The same challenge extends to professionals in the industry, where initial setup can be tedious and time-consuming. To solve this, we created STACKD—a tool that eliminates repetitive setup tasks, allowing developers to focus on building their applications right away.
+We got the motive to build this application because every time me and my team went for a hackathon, it used to take a lot of time to set up the project with basic things like frontend, UI setup, backend, ORM connection, authentication, and other configurations. People in the work environment also struggle with this, so we came up with this idea. STACKD allows programmers to jump directly into coding instead of spending time on tedious setup tasks.
 
 ## 🚀 Features
 
@@ -74,7 +74,7 @@ https://github.com/user-attachments/assets/465451f2-1e1a-48b6-a99e-253ef4f28e2d
 - NextAuth
 - Passport
 
-### 🛆 Installation
+## 📦 Installation
 
 ### Prerequisites
 
@@ -83,17 +83,22 @@ Make sure you have the following installed on your system:
 - Node.js
 - Git
 
-### Using `npm`
+### CLI Tool
+
+To scaffold a new full-stack project, run:
 
 ```sh
-npm i @shivasankaran18/stackd
-npx stackd create
+npm create @shivasankaran18/stackd new proj-name
 ```
 
-### Using `npx`
+This will prompt you with setup questions and generate the project with the selected configurations.
+
+### Web Tool
+
+To launch the web-based setup tool locally, use:
 
 ```sh
-npx @shivasankaran18/stackd create
+npx @shivasankaran18/create-stackd setup
 ```
 
 ## ⚡ Usage

package/apps/cli/src/cli.ts

@@ -15,7 +15,6 @@ export interface ProjectConfig {
   orm: string;
   auth: string;
   dbUrl: string;
-  ui: string;
 }
 
 interface Answers {
@@ -28,8 +27,7 @@ interface Answers {
   orm: string;
   auth: string;
   dbUrl: string;
-  projectName: string;
-  ui: string;
+  projectName:string;
 }
 
 const showBanner = () => {
@@ -69,9 +67,7 @@ const CHOICES = {
   MONGOOSE: 'Mongoose',
   JWT: 'JWT',
   NEXTAUTH: 'NextAuth',
-  PASSPORT: 'Passport',
-  TAILWIND: 'Tailwind CSS',
-  SHADCN: 'shadcn/ui + Tailwind'
+  PASSPORT: 'Passport'
 };
 
 program
@@ -128,27 +124,6 @@ program
       }
     ]);
 
-    // Add UI framework selection after frontend
-    let uiChoice = { ui: CHOICES.NONE };
-    if (frontendChoice.frontend !== chalk.green(CHOICES.DJANGO_TEMPLATES) && 
-        frontendChoice.frontend !== CHOICES.SKIP) {
-      uiChoice = await inquirer.prompt([
-        {
-          type: 'list',
-          name: 'ui',
-          message: chalk.magenta.bold('🎨 Choose a UI framework:'),
-          choices: (answers) => {
-            const isReact = frontendChoice.frontend.includes('React');
-            return [
-              chalk.blue(CHOICES.TAILWIND),
-              ...(isReact ? [chalk.cyan(CHOICES.SHADCN)] : []),
-              CHOICES.NONE
-            ];
-          },
-          default: CHOICES.NONE,
-        }
-      ]);
-    }
 
     const backendChoice = await inquirer.prompt([
       {
@@ -235,7 +210,6 @@ program
     const answers = {
       ...projectSettings,
       ...frontendChoice,
-      ...uiChoice,
       ...backendChoice,
       ...databaseChoice,
       ...ormChoice,

package/apps/cli/src/commands/create.ts

@@ -16,8 +16,6 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { mkdir } from 'fs/promises';
 import { ProjectConfig } from '../cli.js';
-import { setupShadcn } from '../scripts/ui/shadcn.js';
-import { setupTailwindCSS } from '../scripts/ui/tailwindcss.js';
 
 const emitLog = (message: string): void => {
   console.log(`[Emit Logs]: ${message}`);
@@ -66,24 +64,6 @@ export async function createProject(projectName: string, options: ProjectConfig)
         break;
     }
 
-    // UI Framework setup
-    if (options.ui !== 'None' && options.frontend !== 'Django Templates' && options.frontend !== 'Skip') {
-      spinner.text = 'Setting up UI framework...';
-      switch(options.ui) {
-        case 'Tailwind CSS':
-          await setupTailwindCSS(config, projectDir, emitLog);
-          break;
-        case 'shadcn/ui + Tailwind':
-          await setupTailwindCSS(config, projectDir, emitLog);
-          // @ts-ignore
-          await setupShadcn(config, projectDir, emitLog);
-          break;
-        default:
-          emitLog('Unknown UI framework choice');
-          break;
-      }
-    }
-
     // Backend setup
     spinner.text = 'Setting up backend...';
     switch(options.backend) {
@@ -163,16 +143,6 @@ export async function createProject(projectName: string, options: ProjectConfig)
       }
     }
 
-    // Add UI-specific instructions
-    if (options.ui !== 'None') {
-      console.log(chalk.yellow('\nUI Framework Setup:'));
-      if (options.ui === 'Tailwind CSS') {
-        console.log(chalk.cyan('  Tailwind CSS is ready to use'));
-      } else if (options.ui === 'shadcn/ui + Tailwind') {
-        console.log(chalk.cyan('  Run `npx shadcn-ui@latest init` to complete shadcn/ui setup'));
-      }
-    }
-
     // Add database specific instructions
     if (options.database !== 'Skip') {
       console.log(chalk.yellow('\nDatabase Setup:'));

package/apps/cli/src/generators/auth/jwt.js

@@ -0,0 +1,83 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import fs from 'fs';
+
+export async function jwtAuthts(config, projectDir,emitLog) {
+    emitLog('Installing jsonwebtoken...');
+    const packageJsonPath = join(projectDir, 'backend','package.json');
+    const jsonData = await JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    emitLog('Updating package.json...');
+    jsonData.dependencies = jsonData.dependencies || {};
+    jsonData.dependencies["jsonwebtoken"] = "^9.0.2";
+
+    fs.writeFileSync(packageJsonPath, JSON.stringify(jsonData, null, 2), 'utf8');
+    emitLog('Writing jwt.ts...');
+    const jwtAuthFile = `
+    const jwt = require('jsonwebtoken');
+export const authenticateToken = (req:any, res:any, next:any) => {
+    const token = req.header('Authorization')?.split(' ')[1];
+    if (!token) return res.status(401).json({ error: 'Access Denied' });
+
+    jwt.verify(token, process.env.JWT_SECRET, (err:any, user:any) => {
+        if (err) return res.status(403).json({ error: 'Invalid Token' });
+        req.user = user;
+        next();
+    });
+};
+`;
+    emitLog('Writing middleware.ts...');
+    const middlewareDir = join(projectDir, 'backend', 'src', 'middleware');
+    await mkdir(middlewareDir, { recursive: true });
+    emitLog('Writing middleware.ts...');    
+    await writeFile(join(middlewareDir, 'middleware.ts'), jwtAuthFile, 'utf8');
+    emitLog('✅ JWT authentication setup completed successfully!');
+}
+  
+export async function jwtAuthdjango(config , projectDir ,emitLog) {
+    emitLog('Installing jsonwebtoken...');
+    const settingsPath = join(projectDir, 'backend', 'core', 'settings.py');
+    emitLog('Updating settings.py...');
+    try {
+        let settingsContent = fs.readFileSync(settingsPath, 'utf8');
+        const restFrameworkSettings = `
+
+REST_FRAMEWORK = {
+    'DEFAULT_AUTHENTICATION_CLASSES': [
+        'rest_framework_simplejwt.authentication.JWTAuthentication',
+    ],
+}
+`;
+        
+        const installedAppsIndex = settingsContent.indexOf('INSTALLED_APPS');
+        const insertPosition = settingsContent.indexOf(']', installedAppsIndex) + 1;
+        
+        settingsContent = 
+            settingsContent.slice(0, insertPosition) + 
+            restFrameworkSettings + 
+            settingsContent.slice(insertPosition);
+        
+        fs.writeFileSync(settingsPath, settingsContent, 'utf8');
+        emitLog('Writing urls.py...');
+        let urlsContent = fs.readFileSync(`${projectDir}/backend/core/urls.py`, 'utf8');
+        const newUrlsContent = `from django.contrib import admin
+from django.urls import path, include
+from rest_framework_simplejwt import views as jwt_views
+
+urlpatterns = [
+    path('admin/', admin.site.urls),
+    path('api/token/', 
+         jwt_views.TokenObtainPairView.as_view(), 
+         name='token_obtain_pair'),
+    path('api/token/refresh/', 
+         jwt_views.TokenRefreshView.as_view(), 
+         name='token_refresh'),
+    path('', include('main.urls')),
+]
+`;
+        fs.writeFileSync(`${projectDir}/backend/core/urls.py`, newUrlsContent, 'utf8');
+        emitLog('✅ JWT authentication setup completed successfully!');
+    } catch (error) { 
+        console.error('Error configuring Django settings:', error);
+        throw error;
+    }
+}

package/apps/cli/src/generators/auth/nextAuth.js

@@ -0,0 +1,146 @@
+import { join } from 'node:path'
+import { mkdir, writeFile } from 'node:fs/promises'
+import 'dotenv/config'
+
+export async function setupNextAuth(config, projectDir,emitLog) {
+    try {
+        const authDir = join(projectDir, 'frontend', 'src', 'app', 'api', 'auth');
+        await mkdir(authDir, { recursive: true });
+        emitLog('Creating auth directory...');
+        const routeCode = `
+import NextAuth from "next-auth";
+import { AuthOptions } from "next-auth";
+import GithubProvider from "next-auth/providers/github";
+import GoogleProvider from "next-auth/providers/google";
+import CredentialsProvider from "next-auth/providers/credentials";
+export const authOptions: AuthOptions = {
+    providers: [
+        GithubProvider({
+            clientId: process.env.GITHUB_ID!,
+            clientSecret: process.env.GITHUB_SECRET!,
+        }),
+        GoogleProvider({
+            clientId: process.env.GOOGLE_CLIENT_ID!,
+            clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
+        }),
+        CredentialsProvider({
+            name: 'Credentials',
+            credentials: {
+                email: { label: "Email", type: "email" },
+                password: { label: "Password", type: "password" }
+            },
+            async authorize(credentials) {
+                // Add your credentials logic here
+                if (!credentials?.email || !credentials?.password) return null;
+                
+                try {
+                    // Example user verification
+                    const user = { id: "1", email: credentials.email, name: "User" };
+                    return user;
+                } catch (error) {
+                    return null;
+                }
+            }
+        }),
+    ],
+    pages: {
+        signIn: '/auth/signin',
+        signOut: '/auth/signout',
+        error: '/auth/error',
+    },
+    callbacks: {
+        async jwt({ token, user }) {
+            if (user) {
+                token.id = user.id;
+            }
+            return token;
+        },
+        async session({ session, token }) {
+            if (session.user) {
+                (session.user as any).id = token.id;
+            }
+            return session;
+        },
+    },
+    session: {
+        strategy: "jwt",
+    },
+    secret: process.env.NEXTAUTH_SECRET,
+};
+
+const handler = NextAuth(authOptions);
+export { handler as GET, handler as POST };
+`;
+
+        await writeFile(
+            join(authDir, 'route.ts'),
+            routeCode.trim() + '\n'
+        );
+
+        const utilsDir = join(projectDir, 'frontend', 'src', 'utils');
+        await mkdir(utilsDir, { recursive: true });
+        emitLog('Creating utils directory...');
+        const utilsCode = `
+import { getServerSession } from "next-auth/next";
+import { authOptions } from "@/app/api/auth/route";
+
+export async function getSession() {
+    return await getServerSession(authOptions);
+}
+
+export async function getCurrentUser() {
+    const session = await getSession();
+    return session?.user;
+}
+
+export async function isAuthenticated() {
+    const session = await getSession();
+    return !!session;
+}
+`;
+        emitLog('Writing utils.ts...');
+        await writeFile(
+            join(utilsDir, 'auth.ts'),
+            utilsCode.trim() + '\n'
+        );
+
+        const envContent = `
+# NextAuth Configuration
+NEXTAUTH_SECRET=your-secret-key-here
+NEXTAUTH_URL=http://localhost:${config.frontendPort}
+
+# OAuth Providers
+GITHUB_ID=your-github-id
+GITHUB_SECRET=your-github-secret
+
+GOOGLE_CLIENT_ID=your-google-client-id
+GOOGLE_CLIENT_SECRET=your-google-client-secret
+`;
+        emitLog('Writing .env file...');
+        await writeFile(
+            join(projectDir, 'frontend', '.env'),
+            envContent.trim() + '\n'
+        );
+        emitLog('Writing AuthProvider.tsx...');
+        const providerCode = `
+'use client';
+
+import { SessionProvider } from "next-auth/react";
+
+export function AuthProvider({ children }: { children: React.ReactNode }) {
+    return <SessionProvider>{children}</SessionProvider>;
+}
+`;
+        emitLog('Creating components directory...');
+        const providersDir = join(projectDir, 'frontend', 'src', 'components', 'auth');
+        await mkdir(providersDir, { recursive: true });
+        await writeFile(
+            join(providersDir, 'AuthProvider.tsx'),
+            providerCode.trim() + '\n'
+        );
+        emitLog('✅ NextAuth setup completed successfully!');
+    } catch (error) {
+        emitLog(`❌ Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw error;
+    }
+}

package/apps/cli/src/generators/auth/passport.js

@@ -0,0 +1,234 @@
+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/apps/cli/src/generators/backend/django.js

@@ -0,0 +1,30 @@
+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;