@shivasankaran18/stackd 1.8.0 → 2.0.1

package/dist/packages/scripts/Auth/jwt.js

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

@@ -1,131 +0,0 @@
-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/dist/packages/scripts/Auth/passport.js

@@ -1,218 +0,0 @@
-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/packages/scripts/backend/django.js

@@ -1,20 +0,0 @@
-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/packages/scripts/backend/expressjs.js

@@ -1,58 +0,0 @@
-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/packages/scripts/backend/expressts.js

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

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

package/dist/packages/scripts/frontend/angularts.js

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

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