@shivasankaran18/stackd 1.1.0

package/packages/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/packages/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/packages/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/packages/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/packages/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;
+  }
+}`;
+}

package/packages/scripts/ui/tailwindcss.ts

@@ -0,0 +1,126 @@
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { mkdir } from 'fs/promises';
+
+export async function setupTailwindCSS(
+    config: any,
+    projectDir: string,
+    emitLog: (log: string) => void
+) {
+    try {
+        const frontendDir = join(projectDir, 'frontend');
+        const srcDir = join(frontendDir, 'src');
+        
+        // Ensure directories exist
+        if (!existsSync(frontendDir)) {
+            emitLog('Creating frontend directory...');
+            await mkdir(frontendDir, { recursive: true });
+        }
+
+        if (!existsSync(srcDir)) {
+            emitLog('Creating src directory...');
+            await mkdir(srcDir, { recursive: true });
+        }
+
+        // Initialize package.json if it doesn't exist
+        if (!existsSync(join(frontendDir, 'package.json'))) {
+            emitLog('Initializing package.json...');
+            execSync('npm init -y', {
+                cwd: frontendDir,
+                stdio: 'inherit'
+            });
+        }
+
+        // Install dependencies using npm directly
+        emitLog('Installing Tailwind CSS dependencies...');
+        execSync('npm install tailwindcss@latest postcss@latest autoprefixer@latest --save-dev', {
+            cwd: frontendDir,
+            stdio: 'inherit'
+        });
+
+        // Create tailwind.config.js manually instead of using npx
+        emitLog('Creating Tailwind configuration...');
+        const tailwindConfig = generateTailwindConfig(config.frontend);
+        await writeFile(
+            join(frontendDir, 'tailwind.config.js'),
+            tailwindConfig
+        );
+
+        // Create postcss.config.js
+        emitLog('Creating PostCSS configuration...');
+        const postcssConfig = `
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}`;
+        await writeFile(
+            join(frontendDir, 'postcss.config.js'),
+            postcssConfig
+        );
+
+        // Add Tailwind directives to CSS
+        emitLog('Creating CSS file with Tailwind directives...');
+        const tailwindDirectives = `
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+`;
+        await writeFile(
+            join(srcDir, 'index.css'),
+            tailwindDirectives
+        );
+
+        emitLog('✅ Tailwind CSS setup completed successfully!');
+    } catch (error) {
+        emitLog(`❌ Error setting up Tailwind CSS: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw error;
+    }
+}
+
+function generateTailwindConfig(framework: string): string {
+    const baseConfig = {
+        content: [
+            "./index.html",
+            "./src/**/*.{js,ts,jsx,tsx}",
+        ],
+        theme: {
+            extend: {
+                colors: {
+                    background: 'hsl(var(--background))',
+                    foreground: 'hsl(var(--foreground))',
+                },
+            },
+        },
+        plugins: [],
+    };
+
+    switch (framework) {
+        case 'react-ts':
+        case 'react':
+            baseConfig.content = [
+                "./index.html",
+                "./src/**/*.{js,ts,jsx,tsx}",
+            ];
+            break;
+        case 'vue-ts':
+        case 'vue':
+            baseConfig.content = [
+                "./index.html",
+                "./src/**/*.{vue,js,ts,jsx,tsx}",
+            ];
+            break;
+        case 'django':
+            baseConfig.content = [
+                "./templates/**/*.html",
+                "./static/**/*.{js,ts}",
+            ];
+            break;
+    }
+
+    return `/** @type {import('tailwindcss').Config} */
+module.exports = ${JSON.stringify(baseConfig, null, 2)}`;
+}

package/packages/typescript-config/base.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "esModuleInterop": true,
+    "incremental": false,
+    "isolatedModules": true,
+    "lib": ["es2022", "DOM", "DOM.Iterable"],
+    "module": "NodeNext",
+    "moduleDetection": "force",
+    "moduleResolution": "NodeNext",
+    "noUncheckedIndexedAccess": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "ES2022"
+  }
+}

package/packages/typescript-config/nextjs.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./base.json",
+  "compilerOptions": {
+    "plugins": [{ "name": "next" }],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "allowJs": true,
+    "jsx": "preserve",
+    "noEmit": true
+  }
+}

package/packages/typescript-config/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@repo/typescript-config",
+  "version": "0.0.0",
+  "private": true,
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/packages/typescript-config/react-library.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./base.json",
+  "compilerOptions": {
+    "jsx": "react-jsx"
+  }
+}

package/packages/ui/eslint.config.mjs

@@ -0,0 +1,4 @@
+import { config } from "@repo/eslint-config/react-internal";
+
+/** @type {import("eslint").Linter.Config} */
+export default config;

package/packages/ui/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@repo/ui",
+  "version": "0.0.0",
+  "private": true,
+  "exports": {
+    "./*": "./src/*.tsx"
+  },
+  "scripts": {
+    "lint": "eslint . --max-warnings 0",
+    "generate:component": "turbo gen react-component",
+    "check-types": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@repo/eslint-config": "*",
+    "@repo/typescript-config": "*",
+    "@turbo/gen": "^2.4.0",
+    "@types/node": "^22.13.0",
+    "@types/react": "19.0.8",
+    "@types/react-dom": "19.0.3",
+    "eslint": "^9.20.0",
+    "typescript": "5.7.3"
+  },
+  "dependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  }
+}