nextforge-cli 1.0.0

package/templates/base/middleware/auth-middleware.ts

@@ -0,0 +1,42 @@
+import { Context, Next } from 'hono';
+import { getCookie } from 'hono/cookie';
+import { verifyToken, hasPermission, type UserRole, type JWTPayload } from '../lib/auth';
+
+declare module 'hono' {
+  interface ContextVariableMap {
+    user: JWTPayload;
+  }
+}
+
+export async function authMiddleware(c: Context, next: Next) {
+  const token = getCookie(c, 'auth_token');
+
+  if (!token) {
+    return c.json({ success: false, error: 'Not authenticated' }, 401);
+  }
+
+  const payload = verifyToken(token);
+
+  if (!payload) {
+    return c.json({ success: false, error: 'Invalid token' }, 401);
+  }
+
+  c.set('user', payload);
+  await next();
+}
+
+export function requireRole(role: UserRole) {
+  return async (c: Context, next: Next) => {
+    const user = c.get('user');
+
+    if (!user) {
+      return c.json({ success: false, error: 'Not authenticated' }, 401);
+    }
+
+    if (!hasPermission(user, role)) {
+      return c.json({ success: false, error: 'Insufficient permissions' }, 403);
+    }
+
+    await next();
+  };
+}

package/templates/base/next.config.js

@@ -0,0 +1,10 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  output: 'standalone',
+  reactStrictMode: true,
+  images: {
+    domains: [],
+  },
+}
+
+module.exports = nextConfig

package/templates/base/postcss.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

package/templates/base/providers/providers.tsx

@@ -0,0 +1,32 @@
+'use client'
+
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { ThemeProvider } from 'next-themes'
+import { useState } from 'react'
+
+export function Providers({ children }: { children: React.ReactNode }) {
+  const [queryClient] = useState(
+    () =>
+      new QueryClient({
+        defaultOptions: {
+          queries: {
+            staleTime: 60 * 1000,
+            refetchOnWindowFocus: false,
+          },
+        },
+      })
+  )
+
+  return (
+    <QueryClientProvider client={queryClient}>
+      <ThemeProvider
+        attribute="class"
+        defaultTheme="system"
+        enableSystem
+        disableTransitionOnChange
+      >
+        {children}
+      </ThemeProvider>
+    </QueryClientProvider>
+  )
+}

package/templates/base/tailwind.config.ts

@@ -0,0 +1,58 @@
+import type { Config } from "tailwindcss"
+
+const config: Config = {
+  darkMode: ["class"],
+  content: [
+    "./pages/**/*.{js,ts,jsx,tsx,mdx}",
+    "./components/**/*.{js,ts,jsx,tsx,mdx}",
+    "./app/**/*.{js,ts,jsx,tsx,mdx}",
+    "./features/**/*.{js,ts,jsx,tsx,mdx}",
+  ],
+  theme: {
+    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)",
+      },
+    },
+  },
+  plugins: [require("tailwindcss-animate")],
+}
+
+export default config

package/templates/base/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/templates/email/email-service.ts

@@ -0,0 +1,120 @@
+import nodemailer from 'nodemailer';
+import { logger } from '../logger';
+
+interface EmailOptions {
+  to: string | string[];
+  subject: string;
+  text?: string;
+  html?: string;
+}
+
+const transporter = nodemailer.createTransport({
+  host: process.env.SMTP_HOST || 'smtp.gmail.com',
+  port: parseInt(process.env.SMTP_PORT || '587'),
+  secure: process.env.SMTP_SECURE === 'true',
+  auth: process.env.SMTP_USER
+    ? {
+        user: process.env.SMTP_USER,
+        pass: process.env.SMTP_PASSWORD,
+      }
+    : undefined,
+});
+
+export async function sendEmail(options: EmailOptions): Promise<boolean> {
+  try {
+    const from = `${process.env.EMAIL_FROM_NAME || 'App'} <${process.env.EMAIL_FROM || 'noreply@app.com'}>`;
+
+    await transporter.sendMail({
+      from,
+      to: Array.isArray(options.to) ? options.to.join(', ') : options.to,
+      subject: options.subject,
+      text: options.text,
+      html: options.html,
+    });
+
+    logger.info('Email sent successfully', {
+      to: options.to,
+      subject: options.subject,
+    });
+
+    return true;
+  } catch (error: any) {
+    logger.error('Failed to send email', {
+      error: error.message,
+      to: options.to,
+      subject: options.subject,
+    });
+    return false;
+  }
+}
+
+// Email templates
+export function getWelcomeEmailHtml(name: string): string {
+  return `
+    <!DOCTYPE html>
+    <html>
+    <head>
+      <meta charset="utf-8">
+      <style>
+        body { font-family: Arial, sans-serif; line-height: 1.6; color: #333; }
+        .container { max-width: 600px; margin: 0 auto; padding: 20px; }
+        .header { background: #4F46E5; color: white; padding: 20px; text-align: center; }
+        .content { padding: 20px; background: #f9f9f9; }
+        .footer { text-align: center; padding: 20px; color: #666; font-size: 12px; }
+      </style>
+    </head>
+    <body>
+      <div class="container">
+        <div class="header">
+          <h1>Welcome!</h1>
+        </div>
+        <div class="content">
+          <p>Hello ${name},</p>
+          <p>Welcome to our platform! We're excited to have you on board.</p>
+          <p>If you have any questions, feel free to reach out to our support team.</p>
+        </div>
+        <div class="footer">
+          <p>&copy; ${new Date().getFullYear()} Your App. All rights reserved.</p>
+        </div>
+      </div>
+    </body>
+    </html>
+  `;
+}
+
+export function getPasswordResetEmailHtml(resetUrl: string): string {
+  return `
+    <!DOCTYPE html>
+    <html>
+    <head>
+      <meta charset="utf-8">
+      <style>
+        body { font-family: Arial, sans-serif; line-height: 1.6; color: #333; }
+        .container { max-width: 600px; margin: 0 auto; padding: 20px; }
+        .header { background: #4F46E5; color: white; padding: 20px; text-align: center; }
+        .content { padding: 20px; background: #f9f9f9; }
+        .button { display: inline-block; padding: 12px 24px; background: #4F46E5; color: white; text-decoration: none; border-radius: 4px; }
+        .footer { text-align: center; padding: 20px; color: #666; font-size: 12px; }
+      </style>
+    </head>
+    <body>
+      <div class="container">
+        <div class="header">
+          <h1>Password Reset</h1>
+        </div>
+        <div class="content">
+          <p>You requested a password reset. Click the button below to reset your password:</p>
+          <p style="text-align: center;">
+            <a href="${resetUrl}" class="button">Reset Password</a>
+          </p>
+          <p>If you didn't request this, please ignore this email.</p>
+          <p>This link will expire in 1 hour.</p>
+        </div>
+        <div class="footer">
+          <p>&copy; ${new Date().getFullYear()} Your App. All rights reserved.</p>
+        </div>
+      </div>
+    </body>
+    </html>
+  `;
+}

package/templates/stripe/route.ts

@@ -0,0 +1,147 @@
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { z } from 'zod';
+import { authMiddleware } from '@/middleware/auth-middleware';
+import { prisma } from '@/lib/prisma';
+import { logger } from '@/lib/logger';
+import {
+  createCheckoutSession,
+  createPortalSession,
+  handleWebhookEvent,
+} from './stripe-service';
+
+const app = new Hono();
+
+const checkoutSchema = z.object({
+  priceId: z.string(),
+});
+
+// Create checkout session
+app.post(
+  '/checkout',
+  authMiddleware,
+  zValidator('json', checkoutSchema),
+  async (c) => {
+    const user = c.get('user');
+    const { priceId } = c.req.valid('json');
+
+    try {
+      const dbUser = await prisma.user.findUnique({
+        where: { id: user.userId },
+      });
+
+      if (!dbUser) {
+        return c.json({ success: false, error: 'User not found' }, 404);
+      }
+
+      const appUrl = process.env.APP_URL || 'http://localhost:3001';
+      const session = await createCheckoutSession({
+        priceId,
+        userId: user.userId,
+        customerEmail: dbUser.email || undefined,
+        successUrl: `${appUrl}/billing?success=true`,
+        cancelUrl: `${appUrl}/billing?canceled=true`,
+      });
+
+      return c.json({ success: true, data: { url: session.url } });
+    } catch (error: any) {
+      logger.error('Checkout error', { error: error.message });
+      return c.json({ success: false, error: 'Failed to create checkout' }, 500);
+    }
+  }
+);
+
+// Create billing portal session
+app.post('/portal', authMiddleware, async (c) => {
+  const user = c.get('user');
+
+  try {
+    const dbUser = await prisma.user.findUnique({
+      where: { id: user.userId },
+    });
+
+    if (!dbUser?.stripeCustomerId) {
+      return c.json({ success: false, error: 'No billing account found' }, 404);
+    }
+
+    const appUrl = process.env.APP_URL || 'http://localhost:3001';
+    const session = await createPortalSession({
+      customerId: dbUser.stripeCustomerId,
+      returnUrl: `${appUrl}/billing`,
+    });
+
+    return c.json({ success: true, data: { url: session.url } });
+  } catch (error: any) {
+    logger.error('Portal error', { error: error.message });
+    return c.json({ success: false, error: 'Failed to create portal' }, 500);
+  }
+});
+
+// Webhook handler
+app.post('/webhook', async (c) => {
+  const signature = c.req.header('stripe-signature');
+
+  if (!signature) {
+    return c.json({ error: 'Missing signature' }, 400);
+  }
+
+  try {
+    const body = await c.req.text();
+    const event = await handleWebhookEvent(body, signature);
+
+    switch (event.type) {
+      case 'checkout.session.completed': {
+        const session = event.data.object;
+        const userId = parseInt(session.metadata?.userId || '0');
+        const customerId = session.customer as string;
+
+        if (userId) {
+          await prisma.user.update({
+            where: { id: userId },
+            data: { stripeCustomerId: customerId },
+          });
+          logger.info('Customer linked to user', { userId, customerId });
+        }
+        break;
+      }
+
+      case 'customer.subscription.created':
+      case 'customer.subscription.updated': {
+        const subscription = event.data.object;
+        await prisma.subscription.upsert({
+          where: { stripeSubscriptionId: subscription.id },
+          create: {
+            stripeSubscriptionId: subscription.id,
+            userId: 0, // You'll need to look this up via customer ID
+            status: subscription.status,
+            priceId: subscription.items.data[0]?.price.id || '',
+            currentPeriodStart: new Date(subscription.current_period_start * 1000),
+            currentPeriodEnd: new Date(subscription.current_period_end * 1000),
+          },
+          update: {
+            status: subscription.status,
+            currentPeriodStart: new Date(subscription.current_period_start * 1000),
+            currentPeriodEnd: new Date(subscription.current_period_end * 1000),
+          },
+        });
+        break;
+      }
+
+      case 'customer.subscription.deleted': {
+        const subscription = event.data.object;
+        await prisma.subscription.update({
+          where: { stripeSubscriptionId: subscription.id },
+          data: { status: 'canceled' },
+        });
+        break;
+      }
+    }
+
+    return c.json({ received: true });
+  } catch (error: any) {
+    logger.error('Webhook error', { error: error.message });
+    return c.json({ error: 'Webhook error' }, 400);
+  }
+});
+
+export default app;

package/templates/stripe/stripe-service.ts

@@ -0,0 +1,117 @@
+import Stripe from 'stripe';
+import { logger } from '@/lib/logger';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY || '', {
+  apiVersion: '2024-06-20',
+});
+
+export interface CreateCheckoutSessionParams {
+  priceId: string;
+  userId: number;
+  customerEmail?: string;
+  successUrl: string;
+  cancelUrl: string;
+}
+
+export interface CreatePortalSessionParams {
+  customerId: string;
+  returnUrl: string;
+}
+
+export async function createCheckoutSession(
+  params: CreateCheckoutSessionParams
+): Promise<Stripe.Checkout.Session> {
+  try {
+    const session = await stripe.checkout.sessions.create({
+      mode: 'subscription',
+      payment_method_types: ['card'],
+      line_items: [
+        {
+          price: params.priceId,
+          quantity: 1,
+        },
+      ],
+      success_url: params.successUrl,
+      cancel_url: params.cancelUrl,
+      customer_email: params.customerEmail,
+      metadata: {
+        userId: params.userId.toString(),
+      },
+    });
+
+    logger.info('Checkout session created', {
+      sessionId: session.id,
+      userId: params.userId,
+    });
+
+    return session;
+  } catch (error: any) {
+    logger.error('Failed to create checkout session', { error: error.message });
+    throw error;
+  }
+}
+
+export async function createPortalSession(
+  params: CreatePortalSessionParams
+): Promise<Stripe.BillingPortal.Session> {
+  try {
+    const session = await stripe.billingPortal.sessions.create({
+      customer: params.customerId,
+      return_url: params.returnUrl,
+    });
+
+    return session;
+  } catch (error: any) {
+    logger.error('Failed to create portal session', { error: error.message });
+    throw error;
+  }
+}
+
+export async function handleWebhookEvent(
+  body: string,
+  signature: string
+): Promise<Stripe.Event> {
+  const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET || '';
+
+  try {
+    return stripe.webhooks.constructEvent(body, signature, webhookSecret);
+  } catch (error: any) {
+    logger.error('Webhook signature verification failed', {
+      error: error.message,
+    });
+    throw error;
+  }
+}
+
+export async function getCustomerSubscriptions(
+  customerId: string
+): Promise<Stripe.Subscription[]> {
+  try {
+    const subscriptions = await stripe.subscriptions.list({
+      customer: customerId,
+      status: 'all',
+    });
+
+    return subscriptions.data;
+  } catch (error: any) {
+    logger.error('Failed to get subscriptions', { error: error.message });
+    throw error;
+  }
+}
+
+export async function cancelSubscription(
+  subscriptionId: string
+): Promise<Stripe.Subscription> {
+  try {
+    const subscription = await stripe.subscriptions.cancel(subscriptionId);
+
+    logger.info('Subscription cancelled', { subscriptionId });
+
+    return subscription;
+  } catch (error: any) {
+    logger.error('Failed to cancel subscription', { error: error.message });
+    throw error;
+  }
+}
+
+export { stripe };