@girardmedia/bootspring 1.2.0 → 2.0.3

package/core/scaffold.js

@@ -189,6 +189,149 @@ const PRESETS = {
   }
 };
 
+/**
+ * Plugin configurations
+ * Each plugin adds directories, files, dependencies, and env vars
+ */
+const PLUGINS = {
+  // Auth providers
+  clerk: {
+    name: 'Clerk',
+    directories: ['app/(auth)/sign-in/[[...sign-in]]', 'app/(auth)/sign-up/[[...sign-up]]', 'lib/auth'],
+    files: [
+      { path: 'middleware.ts', template: 'clerk/middleware' },
+      { path: 'app/(auth)/sign-in/[[...sign-in]]/page.tsx', template: 'clerk/sign-in' },
+      { path: 'app/(auth)/sign-up/[[...sign-up]]/page.tsx', template: 'clerk/sign-up' },
+      { path: 'lib/auth/clerk.ts', template: 'clerk/auth-utils' }
+    ],
+    dependencies: ['@clerk/nextjs'],
+    devDependencies: [],
+    envVars: ['NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY', 'CLERK_SECRET_KEY', 'NEXT_PUBLIC_CLERK_SIGN_IN_URL', 'NEXT_PUBLIC_CLERK_SIGN_UP_URL']
+  },
+  nextauth: {
+    name: 'NextAuth.js',
+    directories: ['app/api/auth/[...nextauth]', 'lib/auth'],
+    files: [
+      { path: 'app/api/auth/[...nextauth]/route.ts', template: 'nextauth/route' },
+      { path: 'lib/auth/config.ts', template: 'nextauth/config' },
+      { path: 'lib/auth/session.ts', template: 'nextauth/session' }
+    ],
+    dependencies: ['next-auth', '@auth/prisma-adapter'],
+    devDependencies: [],
+    envVars: ['NEXTAUTH_URL', 'NEXTAUTH_SECRET', 'GOOGLE_CLIENT_ID', 'GOOGLE_CLIENT_SECRET']
+  },
+  supabase: {
+    name: 'Supabase Auth',
+    directories: ['lib/supabase'],
+    files: [
+      { path: 'lib/supabase/client.ts', template: 'supabase/client' },
+      { path: 'lib/supabase/server.ts', template: 'supabase/server' },
+      { path: 'middleware.ts', template: 'supabase/middleware' }
+    ],
+    dependencies: ['@supabase/supabase-js', '@supabase/ssr'],
+    devDependencies: [],
+    envVars: ['NEXT_PUBLIC_SUPABASE_URL', 'NEXT_PUBLIC_SUPABASE_ANON_KEY', 'SUPABASE_SERVICE_ROLE_KEY']
+  },
+
+  // Payment providers
+  stripe: {
+    name: 'Stripe',
+    directories: ['app/api/webhooks/stripe', 'lib/stripe'],
+    files: [
+      { path: 'lib/stripe/client.ts', template: 'stripe/client' },
+      { path: 'lib/stripe/products.ts', template: 'stripe/products' },
+      { path: 'app/api/webhooks/stripe/route.ts', template: 'stripe/webhook' }
+    ],
+    dependencies: ['stripe', '@stripe/stripe-js'],
+    devDependencies: [],
+    envVars: ['STRIPE_SECRET_KEY', 'NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY', 'STRIPE_WEBHOOK_SECRET']
+  },
+  paddle: {
+    name: 'Paddle',
+    directories: ['app/api/webhooks/paddle', 'lib/paddle'],
+    files: [
+      { path: 'lib/paddle/client.ts', template: 'paddle/client' },
+      { path: 'app/api/webhooks/paddle/route.ts', template: 'paddle/webhook' }
+    ],
+    dependencies: ['@paddle/paddle-js'],
+    devDependencies: [],
+    envVars: ['PADDLE_API_KEY', 'NEXT_PUBLIC_PADDLE_CLIENT_TOKEN', 'PADDLE_WEBHOOK_SECRET']
+  },
+
+  // Database providers
+  prisma: {
+    name: 'Prisma',
+    directories: ['prisma', 'lib/db'],
+    files: [
+      { path: 'prisma/schema.prisma', template: 'prisma/schema' },
+      { path: 'lib/db/index.ts', template: 'prisma/client' }
+    ],
+    dependencies: ['@prisma/client'],
+    devDependencies: ['prisma'],
+    envVars: ['DATABASE_URL']
+  },
+  drizzle: {
+    name: 'Drizzle',
+    directories: ['drizzle', 'lib/db'],
+    files: [
+      { path: 'drizzle/schema.ts', template: 'drizzle/schema' },
+      { path: 'lib/db/index.ts', template: 'drizzle/client' },
+      { path: 'drizzle.config.ts', template: 'drizzle/config' }
+    ],
+    dependencies: ['drizzle-orm', 'postgres'],
+    devDependencies: ['drizzle-kit'],
+    envVars: ['DATABASE_URL']
+  },
+
+  // AI providers
+  anthropic: {
+    name: 'Anthropic',
+    directories: ['app/api/chat', 'lib/ai'],
+    files: [
+      { path: 'lib/ai/anthropic.ts', template: 'anthropic/client' },
+      { path: 'app/api/chat/route.ts', template: 'anthropic/route' }
+    ],
+    dependencies: ['@anthropic-ai/sdk'],
+    devDependencies: [],
+    envVars: ['ANTHROPIC_API_KEY']
+  },
+  openai: {
+    name: 'OpenAI',
+    directories: ['app/api/chat', 'lib/ai'],
+    files: [
+      { path: 'lib/ai/openai.ts', template: 'openai/client' },
+      { path: 'app/api/chat/route.ts', template: 'openai/route' }
+    ],
+    dependencies: ['openai'],
+    devDependencies: [],
+    envVars: ['OPENAI_API_KEY']
+  },
+
+  // Testing
+  vitest: {
+    name: 'Vitest',
+    directories: ['__tests__'],
+    files: [
+      { path: 'vitest.config.ts', template: 'vitest/config' },
+      { path: '__tests__/example.test.ts', template: 'vitest/example-test' }
+    ],
+    dependencies: [],
+    devDependencies: ['vitest', '@testing-library/react', '@testing-library/jest-dom'],
+    envVars: []
+  },
+  playwright: {
+    name: 'Playwright',
+    directories: ['e2e'],
+    files: [
+      { path: 'playwright.config.ts', template: 'playwright/config' },
+      { path: 'e2e/example.spec.ts', template: 'playwright/example-test' }
+    ],
+    dependencies: [],
+    devDependencies: ['@playwright/test'],
+    envVars: []
+  }
+};
+
 /**
  * File templates
  */
@@ -1014,6 +1157,185 @@ NEXTAUTH_URL=http://localhost:3000
 # STRIPE_SECRET_KEY=sk_test_...
 # STRIPE_PUBLISHABLE_KEY=pk_test_...
 # STRIPE_WEBHOOK_SECRET=whsec_...
+`,
+
+  // Plugin templates - Clerk
+  'clerk/middleware': `import { clerkMiddleware, createRouteMatcher } from '@clerk/nextjs/server';
+
+const isProtectedRoute = createRouteMatcher(['/dashboard(.*)']);
+
+export default clerkMiddleware((auth, req) => {
+  if (isProtectedRoute(req)) auth().protect();
+});
+
+export const config = {
+  matcher: ['/((?!.*\\\\..*|_next).*)', '/', '/(api|trpc)(.*)'],
+};
+`,
+
+  'clerk/sign-in': `import { SignIn } from '@clerk/nextjs';
+
+export default function SignInPage() {
+  return <SignIn />;
+}
+`,
+
+  'clerk/sign-up': `import { SignUp } from '@clerk/nextjs';
+
+export default function SignUpPage() {
+  return <SignUp />;
+}
+`,
+
+  'clerk/auth-utils': `import { auth } from '@clerk/nextjs/server';
+
+export async function getUser() {
+  const { userId } = auth();
+  return userId;
+}
+`,
+
+  // Plugin templates - Prisma
+  'prisma/schema': `generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id        String   @id @default(cuid())
+  email     String   @unique
+  name      String?
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+`,
+
+  'prisma/client': `import { PrismaClient } from '@prisma/client';
+
+const globalForPrisma = globalThis as unknown as {
+  prisma: PrismaClient | undefined;
+};
+
+export const db = globalForPrisma.prisma ?? new PrismaClient();
+
+if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = db;
+`,
+
+  // Plugin templates - Stripe
+  'stripe/client': `import Stripe from 'stripe';
+
+export const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, {
+  apiVersion: '2023-10-16',
+  typescript: true,
+});
+`,
+
+  'stripe/products': `export const PLANS = {
+  free: {
+    name: 'Free',
+    priceId: null,
+    features: ['Feature 1', 'Feature 2'],
+  },
+  pro: {
+    name: 'Pro',
+    priceId: process.env.STRIPE_PRO_PRICE_ID,
+    features: ['All Free features', 'Feature 3', 'Feature 4'],
+  },
+};
+`,
+
+  'stripe/webhook': `import { headers } from 'next/headers';
+import { NextResponse } from 'next/server';
+import { stripe } from '@/lib/stripe/client';
+
+export async function POST(req: Request) {
+  const body = await req.text();
+  const signature = headers().get('stripe-signature')!;
+
+  try {
+    const event = stripe.webhooks.constructEvent(
+      body,
+      signature,
+      process.env.STRIPE_WEBHOOK_SECRET!
+    );
+
+    switch (event.type) {
+      case 'checkout.session.completed':
+        break;
+      case 'customer.subscription.updated':
+        break;
+      case 'customer.subscription.deleted':
+        break;
+    }
+
+    return NextResponse.json({ received: true });
+  } catch (err) {
+    return NextResponse.json({ error: 'Webhook error' }, { status: 400 });
+  }
+}
+`,
+
+  // Plugin templates - Vitest
+  'vitest/config': `import { defineConfig } from 'vitest/config';
+import react from '@vitejs/plugin-react';
+import path from 'path';
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    environment: 'jsdom',
+    globals: true,
+  },
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './'),
+    },
+  },
+});
+`,
+
+  'vitest/example-test': `import { describe, it, expect } from 'vitest';
+
+describe('Example', () => {
+  it('should work', () => {
+    expect(1 + 1).toBe(2);
+  });
+});
+`,
+
+  // Plugin templates - Anthropic
+  'anthropic/client': `import Anthropic from '@anthropic-ai/sdk';
+
+export const anthropic = new Anthropic({
+  apiKey: process.env.ANTHROPIC_API_KEY,
+});
+`,
+
+  'anthropic/route': `import { anthropic } from '@/lib/ai/anthropic';
+import { NextResponse } from 'next/server';
+
+export async function POST(req: Request) {
+  try {
+    const { messages } = await req.json();
+
+    const response = await anthropic.messages.create({
+      model: 'claude-3-sonnet-20240229',
+      max_tokens: 1024,
+      messages,
+    });
+
+    return NextResponse.json(response);
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to get response' },
+      { status: 500 }
+    );
+  }
+}
 `
 };
 
@@ -1067,18 +1389,148 @@ function planScaffold(config, projectRoot) {
   const preset = config._preset || detectPreset(config);
   const presetConfig = PRESETS[preset] || PRESETS.nextjs;
 
+  // Start with preset directories and files
+  const directories = [...presetConfig.directories];
+  const files = presetConfig.files.map(f => ({
+    path: f.path,
+    template: f.template,
+    fullPath: path.join(projectRoot, f.path)
+  }));
+  const dependencies = {
+    dependencies: [...(presetConfig.dependencies?.dependencies || [])],
+    devDependencies: [...(presetConfig.dependencies?.devDependencies || [])]
+  };
+  const envVars = [];
+
+  // Add plugin configurations based on config
+  const plugins = detectPlugins(config);
+
+  for (const pluginName of plugins) {
+    const plugin = PLUGINS[pluginName];
+    if (!plugin) continue;
+
+    // Add plugin directories
+    if (plugin.directories) {
+      for (const dir of plugin.directories) {
+        if (!directories.includes(dir)) {
+          directories.push(dir);
+        }
+      }
+    }
+
+    // Add plugin files
+    if (plugin.files) {
+      for (const f of plugin.files) {
+        // Don't add if file already exists in plan
+        if (!files.some(existing => existing.path === f.path)) {
+          files.push({
+            path: f.path,
+            template: f.template,
+            fullPath: path.join(projectRoot, f.path)
+          });
+        }
+      }
+    }
+
+    // Add plugin dependencies
+    if (plugin.dependencies) {
+      for (const dep of plugin.dependencies) {
+        if (!dependencies.dependencies.includes(dep)) {
+          dependencies.dependencies.push(dep);
+        }
+      }
+    }
+    if (plugin.devDependencies) {
+      for (const dep of plugin.devDependencies) {
+        if (!dependencies.devDependencies.includes(dep)) {
+          dependencies.devDependencies.push(dep);
+        }
+      }
+    }
+
+    // Collect env vars
+    if (plugin.envVars) {
+      for (const envVar of plugin.envVars) {
+        if (!envVars.includes(envVar)) {
+          envVars.push(envVar);
+        }
+      }
+    }
+  }
+
   return {
     preset,
-    directories: presetConfig.directories,
-    files: presetConfig.files.map(f => ({
-      path: f.path,
-      template: f.template,
-      fullPath: path.join(projectRoot, f.path)
-    })),
-    dependencies: presetConfig.dependencies
+    framework: presetConfig.framework,
+    plugins,
+    directories,
+    files,
+    dependencies,
+    envVars
   };
 }
 
+/**
+ * Detect which plugins should be included based on config
+ */
+function detectPlugins(config) {
+  const plugins = [];
+
+  // Auth provider
+  if (config.enableAuth || config.plugins?.auth?.provider) {
+    const authProvider = config.authProvider || config.plugins?.auth?.provider;
+    if (authProvider && PLUGINS[authProvider]) {
+      plugins.push(authProvider);
+    }
+  }
+
+  // Payments provider
+  if (config.enablePayments || config.plugins?.payments?.provider) {
+    const paymentsProvider = config.paymentsProvider || config.plugins?.payments?.provider;
+    if (paymentsProvider && PLUGINS[paymentsProvider]) {
+      plugins.push(paymentsProvider);
+    }
+  }
+
+  // Database provider
+  if (config.plugins?.database?.provider) {
+    const dbProvider = config.plugins.database.provider;
+    if (PLUGINS[dbProvider]) {
+      plugins.push(dbProvider);
+    }
+  } else if (config.stack?.database === 'postgresql' || config.stack?.database === 'mysql') {
+    // Default to prisma for SQL databases
+    plugins.push('prisma');
+  }
+
+  // AI providers (can be multiple)
+  if (config.enableAI || config.plugins?.ai?.enabled || config.plugins?.ai?.providers?.length) {
+    const aiProviders = config.aiProviders || config.plugins?.ai?.providers || [];
+    // Handle legacy single provider config
+    const legacyProvider = config.aiProvider || config.plugins?.ai?.provider;
+    if (legacyProvider && !aiProviders.includes(legacyProvider)) {
+      aiProviders.push(legacyProvider);
+    }
+    for (const provider of aiProviders) {
+      if (provider && PLUGINS[provider]) {
+        plugins.push(provider);
+      }
+    }
+  }
+
+  // Testing
+  if (config.enableTesting || config.plugins?.testing?.provider) {
+    const testProvider = config.testingProvider || config.plugins?.testing?.provider;
+    if (testProvider === 'both') {
+      plugins.push('vitest');
+      plugins.push('playwright');
+    } else if (testProvider && PLUGINS[testProvider]) {
+      plugins.push(testProvider);
+    }
+  }
+
+  return plugins;
+}
+
 /**
  * Detect preset from config
  */
@@ -1125,6 +1577,37 @@ async function execute(plan, projectRoot) {
     }
   }
 
+  // Create package.json if dependencies exist
+  if (plan.dependencies) {
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+      try {
+        const projectName = path.basename(projectRoot);
+        const packageJson = {
+          name: projectName,
+          version: '0.1.0',
+          private: true,
+          scripts: getScriptsForFramework(plan.framework || 'node'),
+          dependencies: {},
+          devDependencies: {}
+        };
+
+        // Add dependencies
+        for (const dep of (plan.dependencies.dependencies || [])) {
+          packageJson.dependencies[dep] = 'latest';
+        }
+        for (const dep of (plan.dependencies.devDependencies || [])) {
+          packageJson.devDependencies[dep] = 'latest';
+        }
+
+        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        result.filesCreated++;
+      } catch (error) {
+        result.warnings.push(`Could not create package.json: ${error.message}`);
+      }
+    }
+  }
+
   // Create files
   for (const file of plan.files) {
     const template = TEMPLATES[file.template];
@@ -1156,6 +1639,41 @@ async function execute(plan, projectRoot) {
   return result;
 }
 
+/**
+ * Get npm scripts based on framework
+ */
+function getScriptsForFramework(framework) {
+  switch (framework) {
+    case 'nextjs':
+      return {
+        dev: 'next dev',
+        build: 'next build',
+        start: 'next start',
+        lint: 'next lint'
+      };
+    case 'react':
+      return {
+        dev: 'vite',
+        build: 'vite build',
+        preview: 'vite preview'
+      };
+    case 'express':
+    case 'node':
+      return {
+        dev: 'tsx watch src/index.ts',
+        build: 'tsc',
+        start: 'node dist/index.js',
+        test: 'vitest'
+      };
+    default:
+      return {
+        dev: 'npm run start',
+        build: 'echo "No build script"',
+        start: 'node index.js'
+      };
+  }
+}
+
 module.exports = {
   getPresets,
   getPresetInfo,