nextforge-cli 1.0.0

package/templates/base/components/ui/button.tsx

@@ -0,0 +1,52 @@
+import * as React from "react"
+import { Slot } from "@radix-ui/react-slot"
+import { cva, type VariantProps } from "class-variance-authority"
+import { cn } from "@/lib/utils"
+
+const buttonVariants = cva(
+  "inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground hover:bg-primary/90",
+        destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/90",
+        outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
+        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground",
+        link: "text-primary underline-offset-4 hover:underline",
+      },
+      size: {
+        default: "h-10 px-4 py-2",
+        sm: "h-9 rounded-md px-3",
+        lg: "h-11 rounded-md px-8",
+        icon: "h-10 w-10",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default",
+    },
+  }
+)
+
+export interface ButtonProps
+  extends React.ButtonHTMLAttributes<HTMLButtonElement>,
+    VariantProps<typeof buttonVariants> {
+  asChild?: boolean
+}
+
+const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
+  ({ className, variant, size, asChild = false, ...props }, ref) => {
+    const Comp = asChild ? Slot : "button"
+    return (
+      <Comp
+        className={cn(buttonVariants({ variant, size, className }))}
+        ref={ref}
+        {...props}
+      />
+    )
+  }
+)
+Button.displayName = "Button"
+
+export { Button, buttonVariants }

package/templates/base/components/ui/card.tsx

@@ -0,0 +1,78 @@
+import * as React from "react"
+import { cn } from "@/lib/utils"
+
+const Card = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn(
+      "rounded-lg border bg-card text-card-foreground shadow-sm",
+      className
+    )}
+    {...props}
+  />
+))
+Card.displayName = "Card"
+
+const CardHeader = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn("flex flex-col space-y-1.5 p-6", className)}
+    {...props}
+  />
+))
+CardHeader.displayName = "CardHeader"
+
+const CardTitle = React.forwardRef<
+  HTMLParagraphElement,
+  React.HTMLAttributes<HTMLHeadingElement>
+>(({ className, ...props }, ref) => (
+  <h3
+    ref={ref}
+    className={cn(
+      "text-2xl font-semibold leading-none tracking-tight",
+      className
+    )}
+    {...props}
+  />
+))
+CardTitle.displayName = "CardTitle"
+
+const CardDescription = React.forwardRef<
+  HTMLParagraphElement,
+  React.HTMLAttributes<HTMLParagraphElement>
+>(({ className, ...props }, ref) => (
+  <p
+    ref={ref}
+    className={cn("text-sm text-muted-foreground", className)}
+    {...props}
+  />
+))
+CardDescription.displayName = "CardDescription"
+
+const CardContent = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div ref={ref} className={cn("p-6 pt-0", className)} {...props} />
+))
+CardContent.displayName = "CardContent"
+
+const CardFooter = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn("flex items-center p-6 pt-0", className)}
+    {...props}
+  />
+))
+CardFooter.displayName = "CardFooter"
+
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent }

package/templates/base/components/ui/input.tsx

@@ -0,0 +1,24 @@
+import * as React from "react"
+import { cn } from "@/lib/utils"
+
+export interface InputProps
+  extends React.InputHTMLAttributes<HTMLInputElement> {}
+
+const Input = React.forwardRef<HTMLInputElement, InputProps>(
+  ({ className, type, ...props }, ref) => {
+    return (
+      <input
+        type={type}
+        className={cn(
+          "flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
+          className
+        )}
+        ref={ref}
+        {...props}
+      />
+    )
+  }
+)
+Input.displayName = "Input"
+
+export { Input }

package/templates/base/components/ui/label.tsx

@@ -0,0 +1,23 @@
+import * as React from "react"
+import * as LabelPrimitive from "@radix-ui/react-label"
+import { cva, type VariantProps } from "class-variance-authority"
+import { cn } from "@/lib/utils"
+
+const labelVariants = cva(
+  "text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
+)
+
+const Label = React.forwardRef<
+  React.ElementRef<typeof LabelPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof LabelPrimitive.Root> &
+    VariantProps<typeof labelVariants>
+>(({ className, ...props }, ref) => (
+  <LabelPrimitive.Root
+    ref={ref}
+    className={cn(labelVariants(), className)}
+    {...props}
+  />
+))
+Label.displayName = LabelPrimitive.Root.displayName
+
+export { Label }

package/templates/base/features/auth/server/route.ts

@@ -0,0 +1,160 @@
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { setCookie, deleteCookie } from 'hono/cookie';
+import { z } from 'zod';
+import { prisma } from '../../../lib/prisma';
+import { generateToken, comparePassword, hashPassword } from '../../../lib/auth';
+import { logger } from '../../../lib/logger';
+import { authMiddleware, requireRole } from '../../../middleware/auth-middleware';
+
+const app = new Hono();
+
+const loginSchema = z.object({
+  username: z.string().min(1),
+  password: z.string().min(1),
+});
+
+const registerSchema = z.object({
+  username: z.string().min(3),
+  email: z.string().email(),
+  password: z.string().min(8),
+  displayName: z.string().optional(),
+});
+
+// Login
+app.post('/login', zValidator('json', loginSchema), async (c) => {
+  const { username, password } = c.req.valid('json');
+
+  try {
+    const user = await prisma.user.findUnique({
+      where: { username },
+    });
+
+    if (!user || !user.password) {
+      return c.json({ success: false, error: 'Invalid credentials' }, 401);
+    }
+
+    const validPassword = await comparePassword(password, user.password);
+    if (!validPassword) {
+      return c.json({ success: false, error: 'Invalid credentials' }, 401);
+    }
+
+    const token = generateToken(user);
+
+    setCookie(c, 'auth_token', token, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === 'production',
+      sameSite: 'Lax',
+      maxAge: 60 * 60 * 24 * 7, // 7 days
+      path: '/',
+    });
+
+    logger.info('Login successful', { username: user.username, role: user.role });
+
+    return c.json({
+      success: true,
+      data: {
+        user: {
+          id: user.id,
+          username: user.username,
+          email: user.email,
+          displayName: user.displayName,
+          role: user.role,
+        },
+      },
+    });
+  } catch (error: any) {
+    logger.error('Login error', { error: error.message });
+    return c.json({ success: false, error: 'Login failed' }, 500);
+  }
+});
+
+// Register
+app.post('/register', zValidator('json', registerSchema), async (c) => {
+  const { username, email, password, displayName } = c.req.valid('json');
+
+  try {
+    // Check if user exists
+    const existing = await prisma.user.findFirst({
+      where: { OR: [{ username }, { email }] },
+    });
+
+    if (existing) {
+      return c.json({ success: false, error: 'User already exists' }, 400);
+    }
+
+    const hashedPassword = await hashPassword(password);
+
+    const user = await prisma.user.create({
+      data: {
+        username,
+        email,
+        password: hashedPassword,
+        displayName: displayName || username,
+        role: 'user',
+      },
+    });
+
+    const token = generateToken(user);
+
+    setCookie(c, 'auth_token', token, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === 'production',
+      sameSite: 'Lax',
+      maxAge: 60 * 60 * 24 * 7,
+      path: '/',
+    });
+
+    logger.info('User registered', { username: user.username });
+
+    return c.json({
+      success: true,
+      data: {
+        user: {
+          id: user.id,
+          username: user.username,
+          email: user.email,
+          displayName: user.displayName,
+          role: user.role,
+        },
+      },
+    });
+  } catch (error: any) {
+    logger.error('Registration error', { error: error.message });
+    return c.json({ success: false, error: 'Registration failed' }, 500);
+  }
+});
+
+// Logout
+app.post('/logout', authMiddleware, (c) => {
+  deleteCookie(c, 'auth_token');
+  return c.json({ success: true });
+});
+
+// Get current user
+app.get('/me', authMiddleware, (c) => {
+  const user = c.get('user');
+  return c.json({ success: true, data: user });
+});
+
+// Admin: Get all users
+app.get('/users', authMiddleware, requireRole('admin'), async (c) => {
+  try {
+    const users = await prisma.user.findMany({
+      select: {
+        id: true,
+        username: true,
+        email: true,
+        displayName: true,
+        role: true,
+        createdAt: true,
+      },
+    });
+    return c.json({ success: true, data: users });
+  } catch (error: any) {
+    logger.error('Failed to get users', { error: error.message });
+    return c.json({ success: false, error: 'Failed to get users' }, 500);
+  }
+});
+
+export default app;

package/templates/base/index.ts

@@ -0,0 +1,75 @@
+import 'dotenv/config';
+import { serve } from '@hono/node-server';
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { logger as honoLogger } from 'hono/logger';
+import { prettyJSON } from 'hono/pretty-json';
+import { logger } from './lib/logger';
+
+// Import routes
+import authRoute from './features/auth/server/route';
+// Add more routes as needed
+
+const app = new Hono();
+
+// Middleware
+app.use('*', cors({
+  origin: (origin) => {
+    if (process.env.NODE_ENV !== 'production') {
+      return origin || '*';
+    }
+    const appUrl = process.env.APP_URL || 'http://localhost:3001';
+    const allowedOrigins = [
+      'http://localhost:3001',
+      appUrl,
+    ];
+    return allowedOrigins.includes(origin || '') ? origin : appUrl;
+  },
+  credentials: true,
+}));
+app.use('*', prettyJSON());
+app.use('*', honoLogger());
+
+// Custom logging middleware
+app.use('*', async (c, next) => {
+  const start = Date.now();
+  await next();
+  const duration = Date.now() - start;
+  logger.info(`${c.req.method} ${c.req.path}`, {
+    method: c.req.method,
+    path: c.req.path,
+    status: c.res.status,
+    duration: `${duration}ms`,
+  });
+});
+
+// Health check
+app.get('/health', (c) => c.json({ status: 'ok', timestamp: new Date().toISOString() }));
+
+// Routes
+app.route('/api/auth', authRoute);
+
+// Root endpoint
+app.get('/', (c) => {
+  return c.json({
+    name: process.env.APP_NAME || 'My App',
+    version: '1.0.0',
+    status: 'running',
+    endpoints: {
+      health: '/health',
+      auth: '/api/auth',
+    },
+  });
+});
+
+// Start server
+const port = parseInt(process.env.API_PORT || '3000');
+console.log(`🚀 API Server running on http://localhost:${port}`);
+
+serve({
+  fetch: app.fetch,
+  port,
+});
+
+export default app;
+export type AppType = typeof app;

package/templates/base/lib/auth.ts

@@ -0,0 +1,74 @@
+import jwt from 'jsonwebtoken';
+import bcrypt from 'bcrypt';
+import { logger } from './logger';
+
+export type UserRole = 'user' | 'admin' | 'super_admin';
+
+export interface User {
+  id: number;
+  username: string;
+  email?: string | null;
+  displayName?: string | null;
+  role: UserRole;
+}
+
+export interface JWTPayload {
+  userId: number;
+  username: string;
+  email?: string | null;
+  displayName?: string | null;
+  role: UserRole;
+}
+
+const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key';
+const JWT_EXPIRES_IN = process.env.JWT_EXPIRES_IN || '7d';
+
+export function generateToken(user: User): string {
+  const payload: JWTPayload = {
+    userId: user.id,
+    username: user.username,
+    email: user.email,
+    displayName: user.displayName,
+    role: user.role as UserRole,
+  };
+
+  return jwt.sign(payload, JWT_SECRET, { expiresIn: JWT_EXPIRES_IN });
+}
+
+export function verifyToken(token: string): JWTPayload | null {
+  try {
+    return jwt.verify(token, JWT_SECRET) as JWTPayload;
+  } catch (error) {
+    logger.warn('Token verification failed', { error });
+    return null;
+  }
+}
+
+export async function hashPassword(password: string): Promise<string> {
+  return bcrypt.hash(password, 10);
+}
+
+export async function comparePassword(password: string, hash: string): Promise<boolean> {
+  return bcrypt.compare(password, hash);
+}
+
+// Role hierarchy
+const ROLE_HIERARCHY: Record<UserRole, number> = {
+  user: 1,
+  admin: 2,
+  super_admin: 3,
+};
+
+export function hasPermission(user: User | JWTPayload, requiredRole: UserRole): boolean {
+  const userLevel = ROLE_HIERARCHY[user.role];
+  const requiredLevel = ROLE_HIERARCHY[requiredRole];
+  return userLevel >= requiredLevel;
+}
+
+export function isAdmin(user: User | JWTPayload): boolean {
+  return hasPermission(user, 'admin');
+}
+
+export function isSuperAdmin(user: User | JWTPayload): boolean {
+  return user.role === 'super_admin';
+}

package/templates/base/lib/logger.ts

@@ -0,0 +1,66 @@
+import winston from 'winston';
+import DailyRotateFile from 'winston-daily-rotate-file';
+import path from 'path';
+
+const LOG_DIR = process.env.LOG_DIR || './logs';
+const LOG_LEVEL = process.env.LOG_LEVEL || 'info';
+
+const customFormat = winston.format.combine(
+  winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+  winston.format.errors({ stack: true }),
+  winston.format.printf(({ level, message, timestamp, ...meta }) => {
+    const metaStr = Object.keys(meta).length ? `\n${JSON.stringify(meta, null, 2)}` : '';
+    return `${timestamp} [${level.toUpperCase()}]: ${message}${metaStr}`;
+  })
+);
+
+const consoleFormat = winston.format.combine(
+  winston.format.colorize(),
+  winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+  winston.format.printf(({ level, message, timestamp }) => {
+    return `${timestamp} [${level}]: ${message}`;
+  })
+);
+
+// Create transports
+const transports: winston.transport[] = [
+  new winston.transports.Console({
+    format: consoleFormat,
+  }),
+];
+
+// Add file transports in production
+if (process.env.NODE_ENV === 'production') {
+  transports.push(
+    new DailyRotateFile({
+      dirname: LOG_DIR,
+      filename: 'app-%DATE%.log',
+      datePattern: 'YYYY-MM-DD',
+      maxSize: '20m',
+      maxFiles: '14d',
+      format: customFormat,
+    }),
+    new DailyRotateFile({
+      dirname: LOG_DIR,
+      filename: 'error-%DATE%.log',
+      datePattern: 'YYYY-MM-DD',
+      maxSize: '20m',
+      maxFiles: '30d',
+      level: 'error',
+      format: customFormat,
+    })
+  );
+}
+
+export const logger = winston.createLogger({
+  level: LOG_LEVEL,
+  format: customFormat,
+  transports,
+});
+
+// Create child loggers for specific modules
+export const createLogger = (module: string) => {
+  return logger.child({ module });
+};
+
+export default logger;

package/templates/base/lib/prisma.ts

@@ -0,0 +1,15 @@
+import { PrismaClient } from '@prisma/client';
+
+const globalForPrisma = globalThis as unknown as {
+  prisma: PrismaClient | undefined;
+};
+
+export const prisma =
+  globalForPrisma.prisma ??
+  new PrismaClient({
+    log: process.env.NODE_ENV === 'development' ? ['query', 'error', 'warn'] : ['error'],
+  });
+
+if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma;
+
+export default prisma;

package/templates/base/lib/rpc.ts

@@ -0,0 +1,35 @@
+import type { AppType } from '../index';
+import { hc } from 'hono/client';
+
+const API_URL = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:3000';
+
+export const client = hc<AppType>(API_URL, {
+  fetch: (input, init) =>
+    fetch(input, {
+      ...init,
+      credentials: 'include',
+    }),
+});
+
+// Helper function for RPC calls with error handling
+export async function rpc<T>(
+  fn: () => Promise<{ json: () => Promise<{ success: boolean; data?: T; error?: string }> }>
+): Promise<T> {
+  try {
+    const res = await fn();
+    const data = await res.json();
+
+    if (!data.success) {
+      throw new Error(data.error || 'Unknown error');
+    }
+
+    return data.data as T;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw error;
+    }
+    throw new Error('Network error');
+  }
+}
+
+export default client;

package/templates/base/lib/store.ts

@@ -0,0 +1,53 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+
+interface User {
+  id: number;
+  username: string;
+  email?: string | null;
+  displayName?: string | null;
+  role: string;
+}
+
+interface AuthState {
+  user: User | null;
+  isAuthenticated: boolean;
+  setUser: (user: User | null) => void;
+  logout: () => void;
+}
+
+export const useAuthStore = create<AuthState>()(
+  persist(
+    (set) => ({
+      user: null,
+      isAuthenticated: false,
+      setUser: (user) => set({ user, isAuthenticated: !!user }),
+      logout: () => set({ user: null, isAuthenticated: false }),
+    }),
+    {
+      name: 'auth-storage',
+    }
+  )
+);
+
+// Generic store creator for app-specific state
+interface AppState {
+  sidebarOpen: boolean;
+  theme: 'light' | 'dark' | 'system';
+  toggleSidebar: () => void;
+  setTheme: (theme: 'light' | 'dark' | 'system') => void;
+}
+
+export const useAppStore = create<AppState>()(
+  persist(
+    (set) => ({
+      sidebarOpen: true,
+      theme: 'system',
+      toggleSidebar: () => set((state) => ({ sidebarOpen: !state.sidebarOpen })),
+      setTheme: (theme) => set({ theme }),
+    }),
+    {
+      name: 'app-storage',
+    }
+  )
+);

package/templates/base/lib/utils.ts

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}