@shivasankaran18/stackd 1.1.0

package/apps/cli/src/scripts/frontend/nextjs.ts

@@ -0,0 +1,72 @@
+// import { join } from 'node:path'
+// import { execSync, ExecSyncOptions } from 'child_process'
+// import { writeFile, mkdir } from 'node:fs/promises'
+// import { existsSync } from 'fs'
+
+// 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/apps/cli/src/scripts/frontend/reactjs.ts

@@ -0,0 +1,36 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { execSync } from 'node:child_process'
+
+export async function createReactJS(config: any, projectDir: string,emitLog: (log: string) => void) {
+    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/apps/cli/src/scripts/frontend/reactts.ts

@@ -0,0 +1,34 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { execSync } from 'node:child_process'
+
+export async function createReactTS(config: any, projectDir: string,emitLog: (log: string) => void) {
+    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/apps/cli/src/scripts/frontend/vuejs.ts

@@ -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: any, projectDir: string,emitLog: (log: string) => void) {
+    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/scripts/frontend/vuets.ts

@@ -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: any, projectDir: string,emitLog: (log: string) => void) {
+    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/scripts/orms/drizzleSetup.ts

@@ -0,0 +1,102 @@
+import { join } from 'node:path'
+import { mkdir, writeFile } from 'node:fs/promises'
+import 'dotenv/config'
+
+export async function setupDrizzle(config: any, projectDir: string, emitLog: (log: string) => void) {
+    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/scripts/orms/mongoSetup.ts

@@ -0,0 +1,68 @@
+import { join } from 'node:path'
+import { mkdir, writeFile } from 'node:fs/promises'
+import 'dotenv/config'
+
+export async function setupMongoose(config: any, projectDir: string,emitLog: (log: string) => void) {
+    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/scripts/orms/prismaSetup.ts

@@ -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: any, projectDir: string,emitLog: (log: string) => void) {
+    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');
+}

package/apps/cli/src/scripts/ui/shadcn.ts

@@ -0,0 +1,228 @@
+import { writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+
+export async function setupShadcn(
+    config: any,
+    projectDir: string,
+    emitLog: (log: string) => void
+) {
+    try {
+        const frontendDir = join(projectDir, 'frontend');
+        emitLog('📦 Setting up shadcn/ui...');
+
+        // Make sure Tailwind is set up first
+        emitLog('Ensuring Tailwind CSS is set up...');
+
+        // Install shadcn/ui dependencies
+        emitLog('Installing shadcn/ui dependencies...');
+        execSync('npm install @shadcn/ui class-variance-authority clsx tailwind-merge lucide-react', {
+            cwd: frontendDir,
+            stdio: 'inherit'
+        });
+
+        // Create components.json configuration
+        const componentsConfig = {
+            $schema: "https://ui.shadcn.com/schema.json",
+            style: "default",
+            rsc: false,
+            tailwind: {
+                config: "tailwind.config.js",
+                css: "src/index.css",
+                baseColor: "slate",
+                cssVariables: true,
+            },
+            aliases: {
+                components: "@/components",
+                utils: "@/lib/utils"
+            }
+        };
+
+        await writeFile(
+            join(frontendDir, 'components.json'),
+            JSON.stringify(componentsConfig, null, 2)
+        );
+
+        // Create utils file
+        const utilsDir = join(frontendDir, 'src', 'lib');
+        if (!existsSync(utilsDir)) {
+            await mkdir(utilsDir, { recursive: true });
+        }
+
+        const utilsContent = `
+import { type ClassValue, clsx } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}
+`;
+
+        await writeFile(
+            join(utilsDir, 'utils.ts'),
+            utilsContent.trim() + '\n'
+        );
+
+        emitLog('✅ shadcn/ui setup completed successfully!');
+    } catch (error) {
+        emitLog(`❌ Error setting up shadcn/ui: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw error;
+    }
+}
+
+function generateShadcnTailwindConfig(frontend: string): string {
+    const baseConfig = {
+        darkMode: ["class"],
+        content: frontend === 'django' 
+            ? ["./templates/**/*.html", "./static/**/*.{js,ts}"]
+            : ["./index.html", "./src/**/*.{js,ts,jsx,tsx,vue}"],
+        theme: {
+            container: {
+                center: true,
+                padding: "2rem",
+                screens: {
+                    "2xl": "1400px",
+                },
+            },
+            extend: {
+                colors: {
+                    border: "hsl(var(--border))",
+                    input: "hsl(var(--input))",
+                    ring: "hsl(var(--ring))",
+                    background: "hsl(var(--background))",
+                    foreground: "hsl(var(--foreground))",
+                    primary: {
+                        DEFAULT: "hsl(var(--primary))",
+                        foreground: "hsl(var(--primary-foreground))",
+                    },
+                    secondary: {
+                        DEFAULT: "hsl(var(--secondary))",
+                        foreground: "hsl(var(--secondary-foreground))",
+                    },
+                    destructive: {
+                        DEFAULT: "hsl(var(--destructive))",
+                        foreground: "hsl(var(--destructive-foreground))",
+                    },
+                    muted: {
+                        DEFAULT: "hsl(var(--muted))",
+                        foreground: "hsl(var(--muted-foreground))",
+                    },
+                    accent: {
+                        DEFAULT: "hsl(var(--accent))",
+                        foreground: "hsl(var(--accent-foreground))",
+                    },
+                    popover: {
+                        DEFAULT: "hsl(var(--popover))",
+                        foreground: "hsl(var(--popover-foreground))",
+                    },
+                    card: {
+                        DEFAULT: "hsl(var(--card))",
+                        foreground: "hsl(var(--card-foreground))",
+                    },
+                },
+                borderRadius: {
+                    lg: "var(--radius)",
+                    md: "calc(var(--radius) - 2px)",
+                    sm: "calc(var(--radius) - 4px)",
+                },
+                keyframes: {
+                    "accordion-down": {
+                        from: { height: "0" },
+                        to: { height: "var(--radix-accordion-content-height)" },
+                    },
+                    "accordion-up": {
+                        from: { height: "var(--radix-accordion-content-height)" },
+                        to: { height: "0" },
+                    },
+                },
+                animation: {
+                    "accordion-down": "accordion-down 0.2s ease-out",
+                    "accordion-up": "accordion-up 0.2s ease-out",
+                },
+            },
+        },
+        plugins: ["require('tailwindcss-animate')"],
+    };
+
+    return `/** @type {import('tailwindcss').Config} */
+export default ${JSON.stringify(baseConfig, null, 2)}`;
+}
+
+function generateShadcnStyles(frontend: string): string {
+    return `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+@layer base {
+  :root {
+    --background: 0 0% 100%;
+    --foreground: 222.2 84% 4.9%;
+
+    --card: 0 0% 100%;
+    --card-foreground: 222.2 84% 4.9%;
+ 
+    --popover: 0 0% 100%;
+    --popover-foreground: 222.2 84% 4.9%;
+ 
+    --primary: 222.2 47.4% 11.2%;
+    --primary-foreground: 210 40% 98%;
+ 
+    --secondary: 210 40% 96.1%;
+    --secondary-foreground: 222.2 47.4% 11.2%;
+ 
+    --muted: 210 40% 96.1%;
+    --muted-foreground: 215.4 16.3% 46.9%;
+ 
+    --accent: 210 40% 96.1%;
+    --accent-foreground: 222.2 47.4% 11.2%;
+ 
+    --destructive: 0 84.2% 60.2%;
+    --destructive-foreground: 210 40% 98%;
+
+    --border: 214.3 31.8% 91.4%;
+    --input: 214.3 31.8% 91.4%;
+    --ring: 222.2 84% 4.9%;
+ 
+    --radius: 0.5rem;
+  }
+ 
+  .dark {
+    --background: 222.2 84% 4.9%;
+    --foreground: 210 40% 98%;
+ 
+    --card: 222.2 84% 4.9%;
+    --card-foreground: 210 40% 98%;
+ 
+    --popover: 222.2 84% 4.9%;
+    --popover-foreground: 210 40% 98%;
+ 
+    --primary: 210 40% 98%;
+    --primary-foreground: 222.2 47.4% 11.2%;
+ 
+    --secondary: 217.2 32.6% 17.5%;
+    --secondary-foreground: 210 40% 98%;
+ 
+    --muted: 217.2 32.6% 17.5%;
+    --muted-foreground: 215 20.2% 65.1%;
+ 
+    --accent: 217.2 32.6% 17.5%;
+    --accent-foreground: 210 40% 98%;
+ 
+    --destructive: 0 62.8% 30.6%;
+    --destructive-foreground: 210 40% 98%;
+ 
+    --border: 217.2 32.6% 17.5%;
+    --input: 217.2 32.6% 17.5%;
+    --ring: 212.7 26.8% 83.9%;
+  }
+}
+ 
+@layer base {
+  * {
+    @apply border-border;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+}`;
+}