@esreekarreddy/ai-prompts 1.0.0

package/instructions/standards/nextjs.md

@@ -0,0 +1,350 @@
+# Next.js Coding Standards
+
+> Conventions for Next.js 15+ with App Router (January 2026)
+
+## File Structure (Next.js 15)
+
+```
+app/
+├── (auth)/                  # Route groups (no URL impact)
+│   ├── login/
+│   │   └── page.tsx
+│   └── layout.tsx          # Auth-specific layout
+├── (dashboard)/
+│   ├── dashboard/
+│   │   ├── page.tsx
+│   │   ├── loading.tsx     # Streaming loading UI
+│   │   └── error.tsx       # Error boundary
+│   └── layout.tsx
+├── api/
+│   └── users/
+│       └── route.ts        # API route
+├── layout.tsx              # Root layout
+├── page.tsx                # Home page
+├── not-found.tsx           # 404 page
+└── globals.css
+```
+
+## Server vs Client Components (Default: Server)
+
+### Server Components (No directive needed)
+```tsx
+// This is a Server Component by default
+export default async function UsersPage() {
+  const users = await db.users.findMany();
+  return <UserList users={users} />;
+}
+```
+
+### Client Components (Only when required)
+```tsx
+'use client';
+
+import { useState } from 'react';
+
+export function Counter() {
+  const [count, setCount] = useState(0);
+  return <button onClick={() => setCount(c => c + 1)}>{count}</button>;
+}
+```
+
+### When to Use 'use client'
+- `useState`, `useEffect`, `useRef`, etc.
+- Event handlers (`onClick`, `onChange`)
+- Browser APIs (`window`, `document`)
+- Third-party client libraries (charts, maps)
+
+## Data Fetching (Next.js 15)
+
+### In Server Components (Direct async/await)
+```tsx
+export default async function Page() {
+  // Default: cached indefinitely
+  const data = await fetch('https://api.example.com/data');
+  
+  // Revalidate every 60 seconds
+  const freshData = await fetch('https://api.example.com/data', {
+    next: { revalidate: 60 }
+  });
+  
+  // Never cache (dynamic data)
+  const dynamicData = await fetch('https://api.example.com/data', {
+    cache: 'no-store'
+  });
+  
+  return <Display data={data} />;
+}
+```
+
+### Database Queries (Direct in Server Components)
+```tsx
+import { db } from '@/lib/db';
+
+export default async function UsersPage() {
+  // Direct database access - no API layer needed
+  const users = await db.users.findMany({
+    take: 10,
+    orderBy: { createdAt: 'desc' }
+  });
+  
+  return <UserList users={users} />;
+}
+```
+
+### Parallel Data Fetching
+```tsx
+export default async function Dashboard() {
+  // Parallel fetching - much faster
+  const [user, posts, analytics] = await Promise.all([
+    getUser(),
+    getPosts(),
+    getAnalytics()
+  ]);
+  
+  return (
+    <>
+      <UserCard user={user} />
+      <PostList posts={posts} />
+      <AnalyticsChart data={analytics} />
+    </>
+  );
+}
+```
+
+## Server Actions (Next.js 15)
+
+### Defining Server Actions
+```tsx
+// lib/actions/users.ts
+'use server';
+
+import { revalidatePath } from 'next/cache';
+import { redirect } from 'next/navigation';
+import { z } from 'zod';
+
+const CreateUserSchema = z.object({
+  name: z.string().min(1),
+  email: z.string().email(),
+});
+
+export async function createUser(formData: FormData) {
+  // Validate with Zod
+  const result = CreateUserSchema.safeParse({
+    name: formData.get('name'),
+    email: formData.get('email'),
+  });
+  
+  if (!result.success) {
+    return { error: result.error.flatten().fieldErrors };
+  }
+  
+  // Create user
+  await db.users.create({ data: result.data });
+  
+  // Revalidate and redirect
+  revalidatePath('/users');
+  redirect('/users');
+}
+```
+
+### Using Server Actions with Forms
+```tsx
+// Simple form
+<form action={createUser}>
+  <input name="name" required />
+  <input name="email" type="email" required />
+  <button type="submit">Create</button>
+</form>
+```
+
+### With useActionState (React 19)
+```tsx
+'use client';
+import { useActionState } from 'react';
+import { createUser } from '@/lib/actions/users';
+
+export function CreateUserForm() {
+  const [state, action, isPending] = useActionState(createUser, null);
+  
+  return (
+    <form action={action}>
+      {state?.error && <p className="text-red-500">{state.error}</p>}
+      <input name="name" disabled={isPending} />
+      <input name="email" type="email" disabled={isPending} />
+      <button type="submit" disabled={isPending}>
+        {isPending ? 'Creating...' : 'Create'}
+      </button>
+    </form>
+  );
+}
+```
+
+### Optimistic Updates (React 19)
+```tsx
+'use client';
+import { useOptimistic } from 'react';
+
+export function TodoList({ todos, addTodo }) {
+  const [optimisticTodos, addOptimisticTodo] = useOptimistic(
+    todos,
+    (state, newTodo) => [...state, { ...newTodo, pending: true }]
+  );
+  
+  async function handleSubmit(formData: FormData) {
+    const newTodo = { title: formData.get('title') as string };
+    addOptimisticTodo(newTodo);
+    await addTodo(newTodo);
+  }
+  
+  return (
+    <>
+      <form action={handleSubmit}>
+        <input name="title" />
+        <button>Add</button>
+      </form>
+      <ul>
+        {optimisticTodos.map(todo => (
+          <li key={todo.id} style={{ opacity: todo.pending ? 0.5 : 1 }}>
+            {todo.title}
+          </li>
+        ))}
+      </ul>
+    </>
+  );
+}
+```
+
+## Route Handlers (API Routes)
+
+```typescript
+// app/api/users/route.ts
+import { NextResponse } from 'next/server';
+import { z } from 'zod';
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const limit = parseInt(searchParams.get('limit') || '10');
+  
+  const users = await db.users.findMany({ take: limit });
+  return NextResponse.json(users);
+}
+
+export async function POST(request: Request) {
+  const body = await request.json();
+  
+  // Validate
+  const result = UserSchema.safeParse(body);
+  if (!result.success) {
+    return NextResponse.json(
+      { error: result.error.flatten() },
+      { status: 400 }
+    );
+  }
+  
+  const user = await db.users.create({ data: result.data });
+  return NextResponse.json(user, { status: 201 });
+}
+```
+
+## Streaming & Suspense
+
+### Loading UI (Automatic Suspense)
+```tsx
+// app/dashboard/loading.tsx
+export default function Loading() {
+  return <DashboardSkeleton />;
+}
+```
+
+### Manual Suspense Boundaries
+```tsx
+import { Suspense } from 'react';
+
+export default function Page() {
+  return (
+    <>
+      <Header />
+      <Suspense fallback={<PostsSkeleton />}>
+        <Posts />
+      </Suspense>
+      <Suspense fallback={<CommentsSkeleton />}>
+        <Comments />
+      </Suspense>
+    </>
+  );
+}
+```
+
+## Error Handling
+
+```tsx
+// app/dashboard/error.tsx
+'use client';
+
+export default function Error({
+  error,
+  reset,
+}: {
+  error: Error & { digest?: string };
+  reset: () => void;
+}) {
+  return (
+    <div className="p-4 bg-red-50 rounded">
+      <h2 className="text-red-800 font-bold">Something went wrong!</h2>
+      <p className="text-red-600">{error.message}</p>
+      <button 
+        onClick={reset}
+        className="mt-2 px-4 py-2 bg-red-600 text-white rounded"
+      >
+        Try again
+      </button>
+    </div>
+  );
+}
+```
+
+## Metadata (SEO)
+
+```tsx
+// Static metadata
+export const metadata = {
+  title: 'Page Title',
+  description: 'Page description',
+  openGraph: {
+    title: 'OG Title',
+    description: 'OG Description',
+    images: ['/og-image.png'],
+  },
+};
+
+// Dynamic metadata
+export async function generateMetadata({ params }) {
+  const product = await getProduct(params.id);
+  return {
+    title: product.name,
+    description: product.description,
+  };
+}
+```
+
+## Patterns to Avoid (Anti-patterns)
+
+| ❌ Avoid | ✅ Instead |
+|----------|-----------|
+| `useEffect` for data fetching | Fetch in Server Components |
+| `'use client'` by default | Server Components by default |
+| Deep prop drilling | Server Components with direct data |
+| `getServerSideProps` | Server Components or Route Handlers |
+| API routes for internal data | Server Actions or direct DB access |
+| `useState` for server data | Server Components + Suspense |
+| Manual loading states | `loading.tsx` + Suspense |
+
+## Performance Checklist
+
+- [ ] Use Server Components by default
+- [ ] Parallel data fetching with `Promise.all`
+- [ ] Streaming with Suspense for slow data
+- [ ] Image optimization with `next/image`
+- [ ] Font optimization with `next/font`
+- [ ] Route prefetching enabled (default)
+- [ ] Static generation where possible

package/instructions/standards/nodejs.md

@@ -0,0 +1,284 @@
+# Node.js Coding Standards
+
+> Conventions for Node.js/Express backend services
+
+## Project Structure
+
+```
+src/
+├── index.ts              # Entry point
+├── app.ts                # Express app setup
+├── config/
+│   ├── env.ts           # Environment variables
+│   └── database.ts      # DB configuration
+├── routes/
+│   ├── index.ts         # Route aggregator
+│   └── users.ts         # User routes
+├── controllers/
+│   └── users.controller.ts
+├── services/
+│   └── users.service.ts
+├── repositories/
+│   └── users.repository.ts
+├── middleware/
+│   ├── auth.ts
+│   ├── error-handler.ts
+│   └── validate.ts
+├── schemas/              # Zod schemas
+│   └── user.schema.ts
+├── types/
+│   └── index.ts
+└── utils/
+    ├── logger.ts
+    └── errors.ts
+```
+
+## Express App Setup
+
+```typescript
+// src/app.ts
+import express from 'express';
+import cors from 'cors';
+import helmet from 'helmet';
+import { errorHandler } from './middleware/error-handler';
+import routes from './routes';
+
+const app = express();
+
+// Middleware
+app.use(helmet());
+app.use(cors());
+app.use(express.json());
+
+// Routes
+app.use('/api', routes);
+
+// Error handler (must be last)
+app.use(errorHandler);
+
+export default app;
+```
+
+## Routes
+
+```typescript
+// src/routes/users.ts
+import { Router } from 'express';
+import * as controller from '../controllers/users.controller';
+import { validate } from '../middleware/validate';
+import { createUserSchema, updateUserSchema } from '../schemas/user.schema';
+import { authenticate } from '../middleware/auth';
+
+const router = Router();
+
+router.get('/', authenticate, controller.list);
+router.get('/:id', authenticate, controller.get);
+router.post('/', validate(createUserSchema), controller.create);
+router.patch('/:id', authenticate, validate(updateUserSchema), controller.update);
+router.delete('/:id', authenticate, controller.remove);
+
+export default router;
+```
+
+## Controllers
+
+```typescript
+// src/controllers/users.controller.ts
+import { Request, Response, NextFunction } from 'express';
+import * as userService from '../services/users.service';
+
+export async function list(req: Request, res: Response, next: NextFunction) {
+  try {
+    const users = await userService.findAll();
+    res.json(users);
+  } catch (error) {
+    next(error);
+  }
+}
+
+export async function get(req: Request, res: Response, next: NextFunction) {
+  try {
+    const { id } = req.params;
+    const user = await userService.findById(id);
+    if (!user) {
+      return res.status(404).json({ error: 'User not found' });
+    }
+    res.json(user);
+  } catch (error) {
+    next(error);
+  }
+}
+
+export async function create(req: Request, res: Response, next: NextFunction) {
+  try {
+    const user = await userService.create(req.body);
+    res.status(201).json(user);
+  } catch (error) {
+    next(error);
+  }
+}
+```
+
+## Services
+
+```typescript
+// src/services/users.service.ts
+import * as userRepo from '../repositories/users.repository';
+import { CreateUserInput, UpdateUserInput } from '../schemas/user.schema';
+import { AppError } from '../utils/errors';
+import { hashPassword } from '../utils/auth';
+
+export async function findAll() {
+  return userRepo.findMany();
+}
+
+export async function findById(id: string) {
+  return userRepo.findById(id);
+}
+
+export async function create(data: CreateUserInput) {
+  const existing = await userRepo.findByEmail(data.email);
+  if (existing) {
+    throw new AppError('Email already exists', 409);
+  }
+  
+  const hashedPassword = await hashPassword(data.password);
+  return userRepo.create({
+    ...data,
+    password: hashedPassword
+  });
+}
+```
+
+## Validation with Zod
+
+```typescript
+// src/schemas/user.schema.ts
+import { z } from 'zod';
+
+export const createUserSchema = z.object({
+  body: z.object({
+    email: z.string().email('Invalid email'),
+    name: z.string().min(2, 'Name too short').max(100),
+    password: z.string().min(8, 'Password must be at least 8 characters')
+  })
+});
+
+export const updateUserSchema = z.object({
+  body: z.object({
+    name: z.string().min(2).max(100).optional(),
+    email: z.string().email().optional()
+  }),
+  params: z.object({
+    id: z.string()
+  })
+});
+
+export type CreateUserInput = z.infer<typeof createUserSchema>['body'];
+export type UpdateUserInput = z.infer<typeof updateUserSchema>['body'];
+```
+
+## Validation Middleware
+
+```typescript
+// src/middleware/validate.ts
+import { Request, Response, NextFunction } from 'express';
+import { ZodSchema } from 'zod';
+
+export function validate(schema: ZodSchema) {
+  return (req: Request, res: Response, next: NextFunction) => {
+    const result = schema.safeParse({
+      body: req.body,
+      query: req.query,
+      params: req.params
+    });
+    
+    if (!result.success) {
+      return res.status(400).json({
+        error: 'Validation failed',
+        details: result.error.issues
+      });
+    }
+    
+    next();
+  };
+}
+```
+
+## Error Handling
+
+```typescript
+// src/utils/errors.ts
+export class AppError extends Error {
+  constructor(
+    message: string,
+    public statusCode: number = 500,
+    public code?: string
+  ) {
+    super(message);
+    this.name = 'AppError';
+  }
+}
+
+export class NotFoundError extends AppError {
+  constructor(resource: string) {
+    super(`${resource} not found`, 404, 'NOT_FOUND');
+  }
+}
+
+// src/middleware/error-handler.ts
+import { Request, Response, NextFunction } from 'express';
+import { AppError } from '../utils/errors';
+import { logger } from '../utils/logger';
+
+export function errorHandler(
+  err: Error,
+  req: Request,
+  res: Response,
+  next: NextFunction
+) {
+  if (err instanceof AppError) {
+    return res.status(err.statusCode).json({
+      error: { message: err.message, code: err.code }
+    });
+  }
+  
+  logger.error('Unhandled error', { error: err, path: req.path });
+  res.status(500).json({ error: { message: 'Internal server error' } });
+}
+```
+
+## Configuration
+
+```typescript
+// src/config/env.ts
+import { z } from 'zod';
+
+const envSchema = z.object({
+  NODE_ENV: z.enum(['development', 'test', 'production']).default('development'),
+  PORT: z.coerce.number().default(3000),
+  DATABASE_URL: z.string(),
+  JWT_SECRET: z.string()
+});
+
+export const env = envSchema.parse(process.env);
+```
+
+## Async Handler Wrapper
+
+```typescript
+// Avoid try/catch in every controller
+import { Request, Response, NextFunction, RequestHandler } from 'express';
+
+export function asyncHandler(fn: RequestHandler): RequestHandler {
+  return (req, res, next) => {
+    Promise.resolve(fn(req, res, next)).catch(next);
+  };
+}
+
+// Usage
+router.get('/', asyncHandler(async (req, res) => {
+  const users = await userService.findAll();
+  res.json(users);
+}));
+```