@shivasankaran18/stackd 1.6.0 → 1.8.0

package/dist/apps/cli/src/cli.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { createProject } from './commands/create.js';
+const showBanner = () => {
+    console.log(chalk.cyan(`
+     ██████╗████████╗ █████╗  ██████╗██╗  ██╗'██████╗ 
+    ██╔════╝╚══██╔══╝██╔══██╗██╔════╝██║ ██╔╝██╔══██╗
+    ╚█████╗    ██║   ███████║██║     █████═╝ ██║  ██║
+     ╚═══██╗   ██║   ██╔══██║██║     ██╔═██╗ ██║  ██║
+    ██████╔╝   ██║   ██║  ██║╚██████╗██║  ██╗██████╔╝
+    ╚═════╝    ╚═╝   ╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝╚═════╝ 
+  `));
+    console.log(chalk.yellow.bold('  🚀 Full Stack Project Generator\n'));
+};
+const createBorder = () => {
+    const border = '='.repeat(60);
+    return chalk.cyan(border);
+};
+const CHOICES = {
+    EXPRESS_TS: 'Express + TypeScript',
+    EXPRESS_JS: 'Express (JavaScript)',
+    DJANGO: 'Django',
+    REACT_TS: 'React + TypeScript',
+    REACT_JS: 'React (JavaScript)',
+    VUE_TS: 'Vue + TypeScript',
+    VUE_JS: 'Vue (JavaScript)',
+    DJANGO_TEMPLATES: 'Django Templates',
+    NONE: 'None',
+    SKIP: 'Skip',
+    POSTGRESQL: 'PostgreSQL',
+    MONGODB: 'MongoDB',
+    PRISMA: 'Prisma',
+    DRIZZLE: 'Drizzle',
+    MONGOOSE: 'Mongoose',
+    JWT: 'JWT',
+    NEXTAUTH: 'NextAuth',
+    PASSPORT: 'Passport'
+};
+program
+    .command('run ')
+    .description('Create a new full-stack project')
+    .action(async () => {
+    // showBanner();
+    // console.log(createBorder());
+    // console.log(chalk.bgCyan.white.bold('\n  💫 Let\'s create something awesome!  \n'));
+    // console.log(createBorder() + '\n');
+    const projectSettings = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'projectPath',
+            message: chalk.magenta.bold('📁 Where do you want to create the project?'),
+        },
+        {
+            type: 'input',
+            name: 'projectName',
+            message: chalk.magenta.bold('💫 Enter the project name:'),
+        },
+        {
+            type: 'number',
+            name: 'frontendPort',
+            message: chalk.blue.bold('🌐 Enter frontend port:'),
+            default: 3000,
+        },
+        {
+            type: 'number',
+            name: 'backendPort',
+            message: chalk.green.bold('⚙️  Enter backend port:'),
+            default: 3001,
+        }
+    ]);
+    const frontendChoice = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'frontend',
+            message: chalk.yellow.bold('🎨 Choose a frontend framework:'),
+            choices: [
+                chalk.blue(CHOICES.REACT_TS),
+                chalk.blue(CHOICES.REACT_JS),
+                chalk.green(CHOICES.VUE_TS),
+                chalk.green(CHOICES.VUE_JS),
+                chalk.green(CHOICES.DJANGO_TEMPLATES),
+                CHOICES.SKIP
+            ],
+            default: CHOICES.SKIP,
+        }
+    ]);
+    const backendChoice = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'backend',
+            message: chalk.cyan.bold('🛠️  Choose a backend framework:'),
+            choices: (answers) => {
+                if (frontendChoice.frontend === chalk.green(CHOICES.DJANGO_TEMPLATES)) {
+                    return [chalk.green(CHOICES.DJANGO)];
+                }
+                return [
+                    chalk.blue(CHOICES.EXPRESS_TS),
+                    chalk.blue(CHOICES.EXPRESS_JS),
+                    chalk.green(CHOICES.DJANGO),
+                    CHOICES.SKIP
+                ];
+            },
+            default: chalk.blue(CHOICES.EXPRESS_TS),
+        }
+    ]);
+    const databaseChoice = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'database',
+            message: chalk.magenta.bold('🗄️  Choose a database:'),
+            choices: [
+                chalk.blue(CHOICES.POSTGRESQL),
+                chalk.green(CHOICES.MONGODB),
+                CHOICES.SKIP
+            ],
+            default: CHOICES.SKIP,
+        }
+    ]);
+    let ormChoice = { orm: CHOICES.SKIP };
+    if (databaseChoice.database !== CHOICES.SKIP) {
+        ormChoice = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'orm',
+                message: chalk.yellow.bold('🔗 Choose an ORM:'),
+                choices: () => {
+                    const cleanDatabase = databaseChoice.database.replace(/\u001b\[\d+m/g, '').trim();
+                    return cleanDatabase === CHOICES.POSTGRESQL
+                        ? [chalk.magenta(CHOICES.PRISMA), chalk.cyan(CHOICES.DRIZZLE), CHOICES.SKIP]
+                        : [chalk.green(CHOICES.MONGOOSE), CHOICES.SKIP];
+                },
+                default: CHOICES.SKIP,
+            }
+        ]);
+    }
+    // Step 6: Authentication Selection
+    const authChoice = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'auth',
+            message: chalk.cyan.bold('🔐 Choose an authentication method:'),
+            choices: [
+                chalk.yellow(CHOICES.JWT),
+                chalk.blue(CHOICES.NEXTAUTH),
+                chalk.green(CHOICES.PASSPORT),
+                CHOICES.SKIP
+            ],
+            default: CHOICES.SKIP,
+        }
+    ]);
+    let dbUrlChoice = { dbUrl: '' };
+    if (databaseChoice.database !== CHOICES.SKIP) {
+        dbUrlChoice = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'dbUrl',
+                message: chalk.green.bold('🔌 Enter database connection URL:'),
+            }
+        ]);
+    }
+    const answers = {
+        ...projectSettings,
+        ...frontendChoice,
+        ...backendChoice,
+        ...databaseChoice,
+        ...ormChoice,
+        ...authChoice,
+        ...dbUrlChoice,
+    };
+    const cleanAnswers = Object.entries(answers).reduce((acc, [key, value]) => {
+        if (typeof value === 'string') {
+            const cleanValue = value.replace(/\u001b\[\d+m/g, '').trim();
+            // @ts-ignore
+            acc[key] = cleanValue;
+        }
+        else {
+            // @ts-ignore
+            acc[key] = value;
+        }
+        return acc;
+    }, {});
+    // @ts-ignore
+    if (cleanAnswers.database !== 'Skip' && cleanAnswers.orm !== 'Skip') {
+        // @ts-ignore
+        if (cleanAnswers.database === 'MongoDB' && cleanAnswers.orm !== 'Mongoose') {
+            console.log('\n' + createBorder());
+            console.error(chalk.bgRed.white.bold(" ❌ Error: MongoDB supports only Mongoose ORM. "));
+            console.log(createBorder());
+            process.exit(1);
+        }
+        // @ts-ignore
+        if (cleanAnswers.database === 'PostgreSQL' && !['Prisma', 'Drizzle'].includes(cleanAnswers.orm)) {
+            console.log('\n' + createBorder());
+            console.error(chalk.bgRed.white.bold(" ❌ Error: PostgreSQL supports only Prisma or Drizzle ORM. "));
+            console.log(createBorder());
+            process.exit(1);
+        }
+    }
+    // @ts-ignore
+    if (cleanAnswers.frontend === 'Django Templates') {
+        // @ts-ignore
+        cleanAnswers.backend = 'Django';
+    }
+    // @ts-ignore
+    if (cleanAnswers.backend === 'Django') {
+        // @ts-ignore
+        cleanAnswers.frontend = 'Django Templates';
+    }
+    console.log('\n' + createBorder());
+    console.log(chalk.bgGreen.black.bold("\n 📦 Creating your project... \n"));
+    console.log(createBorder() + '\n');
+    // @ts-ignore
+    await createProject(projectSettings.projectName, cleanAnswers);
+});
+program.parse(process.argv);

package/dist/apps/cli/src/commands/create.js

@@ -0,0 +1,148 @@
+import { join } from 'path';
+import { createReactTS } from '../scripts/frontend/reactts.js';
+import { createReactJS } from '../scripts/frontend/reactjs.js';
+import { createVueTS } from '../scripts/frontend/vuets.js';
+import { createVueJS } from '../scripts/frontend/vuejs.js';
+import { createExpressTS } from '../scripts/backend/expressts.js';
+import { createExpressJS } from '../scripts/backend/expressjs.js';
+import { installDjangoDependencies } from '../scripts/backend/django.js';
+import { setupPrisma } from '../scripts/orms/prismaSetup.js';
+import { setupDrizzle } from '../scripts/orms/drizzleSetup.js';
+import { setupMongoose } from '../scripts/orms/mongoSetup.js';
+import { setupPassport } from '../scripts/Auth/passport.js';
+import { jwtAuthts } from '../scripts/Auth/jwt.js';
+import chalk from 'chalk';
+import ora from 'ora';
+import { mkdir } from 'fs/promises';
+const emitLog = (message) => {
+    console.log(`[Emit Logs]: ${message}`);
+};
+export async function createProject(projectName, options) {
+    const spinner = ora('Creating project...').start();
+    console.log(options);
+    console.log(projectName);
+    try {
+        const projectDir = join(options.projectPath, projectName);
+        const config = {
+            projectName,
+            projectPath: options.projectPath,
+            frontendPort: options.frontendPort,
+            backendPort: options.backendPort,
+            dbUrl: options.dbUrl,
+        };
+        // Create project directory
+        await mkdir(projectDir, { recursive: true });
+        // Frontend setup
+        spinner.text = 'Setting up frontend...';
+        switch (options.frontend) {
+            case 'React + TypeScript':
+                await createReactTS(config, projectDir, emitLog);
+                break;
+            case 'React (JavaScript)':
+                await createReactJS(config, projectDir, emitLog);
+                break;
+            case 'Vue + TypeScript':
+                await createVueTS(config, projectDir, emitLog);
+                break;
+            case 'Vue (JavaScript)':
+                await createVueJS(config, projectDir, emitLog);
+                break;
+            case 'Django Templates':
+                // Django templates will be handled with backend setup
+                break;
+            case 'Skip':
+                emitLog('Skipping frontend setup');
+                break;
+            default:
+                emitLog('Unknown frontend choice');
+                break;
+        }
+        // Backend setup
+        spinner.text = 'Setting up backend...';
+        switch (options.backend) {
+            case 'Express + TypeScript':
+                await createExpressTS(config, projectDir, emitLog);
+                break;
+            case 'Express (JavaScript)':
+                await createExpressJS(config, projectDir, emitLog);
+                break;
+            case 'Django':
+                await installDjangoDependencies(projectDir);
+                break;
+            case 'Skip':
+                emitLog('Skipping backend setup');
+                break;
+            default:
+                emitLog('Unknown backend choice');
+                break;
+        }
+        // Database & ORM setup
+        if (options.database !== 'Skip') {
+            spinner.text = 'Setting up database and ORM...';
+            // Set up ORM based on database choice
+            if (options.orm !== 'Skip') {
+                switch (options.orm) {
+                    case 'Prisma':
+                        await setupPrisma(config, projectDir, emitLog);
+                        break;
+                    case 'Drizzle':
+                        await setupDrizzle(config, projectDir, emitLog);
+                        break;
+                    case 'Mongoose':
+                        await setupMongoose(config, projectDir, emitLog);
+                        break;
+                    default:
+                        emitLog('Unknown ORM choice');
+                        break;
+                }
+            }
+        }
+        // Authentication setup
+        if (options.auth !== 'Skip') {
+            spinner.text = 'Setting up authentication...';
+            switch (options.auth) {
+                case 'JWT':
+                    await jwtAuthts(config, projectDir, emitLog);
+                    break;
+                // case 'NextAuth':
+                //   await setupNextAuth(config, projectDir,emitLog);
+                //   break;
+                case 'Passport':
+                    await setupPassport(config, projectDir, emitLog);
+                    break;
+                default:
+                    emitLog('Unknown authentication choice');
+                    break;
+            }
+        }
+        spinner.succeed(chalk.green('Project created successfully!'));
+        console.log('\nTo get started:');
+        console.log(chalk.cyan(`  cd ${projectName}`));
+        // Add specific instructions based on choices
+        if (options.frontend !== 'Skip' || options.backend !== 'Skip') {
+            // console.log(chalk.cyan('  npm install'));
+            if (options.frontend === 'Django Templates' || options.backend === 'Django') {
+                console.log(chalk.cyan('  python manage.py runserver'));
+            }
+            else {
+                console.log(chalk.cyan('  npm run dev'));
+            }
+        }
+        // Add database specific instructions
+        if (options.database !== 'Skip') {
+            console.log(chalk.yellow('\nDatabase Setup:'));
+            if (options.orm === 'Prisma') {
+                console.log(chalk.cyan('  npx prisma generate'));
+                console.log(chalk.cyan('  npx prisma migrate dev'));
+            }
+            else if (options.orm === 'Mongoose') {
+                console.log(chalk.cyan('  Make sure MongoDB is running'));
+            }
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to create project'));
+        console.error(error);
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,78 @@
+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/dist/apps/cli/src/scripts/Auth/nextAuth.js

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