render-create 0.1.0

package/templates/cursor/rules/drizzle.mdc

@@ -0,0 +1,165 @@
+---
+description: Drizzle ORM conventions for PostgreSQL
+globs: ["**/db/**/*.ts", "**/schema/**/*.ts", "**/drizzle/**/*.ts"]
+---
+
+# Drizzle ORM Conventions
+
+## Project Structure
+
+### Small projects: Single schema file
+```
+src/
+├── db/
+│   ├── index.ts      # Database connection
+│   ├── schema.ts     # All tables
+│   └── migrations/   # Generated migrations
+```
+
+### Larger projects: Split by domain
+```
+src/
+├── db/
+│   ├── index.ts
+│   ├── schema/
+│   │   ├── index.ts  # Re-exports all schemas
+│   │   ├── users.ts
+│   │   ├── posts.ts
+│   │   └── comments.ts
+│   └── migrations/
+```
+
+## Database Connection
+
+```typescript
+// db/index.ts
+import { drizzle } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
+import * as schema from "./schema";
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+});
+
+export const db = drizzle(pool, { schema });
+```
+
+## Schema Definition
+
+```typescript
+// db/schema/users.ts
+import { pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+
+export const users = pgTable("users", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  email: text("email").notNull().unique(),
+  name: text("name").notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull(),
+});
+
+// Type inference
+export type User = typeof users.$inferSelect;
+export type NewUser = typeof users.$inferInsert;
+```
+
+## Queries
+
+```typescript
+import { db } from "./db";
+import { users } from "./db/schema";
+import { eq } from "drizzle-orm";
+
+// Select all
+const allUsers = await db.select().from(users);
+
+// Select with filter
+const user = await db
+  .select()
+  .from(users)
+  .where(eq(users.email, "test@example.com"));
+
+// Insert
+const newUser = await db
+  .insert(users)
+  .values({ email: "new@example.com", name: "New User" })
+  .returning();
+
+// Update
+await db
+  .update(users)
+  .set({ name: "Updated Name" })
+  .where(eq(users.id, userId));
+
+// Delete
+await db.delete(users).where(eq(users.id, userId));
+```
+
+## Relations
+
+```typescript
+import { relations } from "drizzle-orm";
+
+export const usersRelations = relations(users, ({ many }) => ({
+  posts: many(posts),
+}));
+
+export const postsRelations = relations(posts, ({ one }) => ({
+  author: one(users, {
+    fields: [posts.authorId],
+    references: [users.id],
+  }),
+}));
+
+// Query with relations
+const usersWithPosts = await db.query.users.findMany({
+  with: {
+    posts: true,
+  },
+});
+```
+
+## Zod Integration with drizzle-zod
+
+```typescript
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import { users } from "./schema";
+
+// Auto-generate Zod schemas from Drizzle tables
+export const insertUserSchema = createInsertSchema(users, {
+  email: (schema) => schema.email.email(),
+});
+
+export const selectUserSchema = createSelectSchema(users);
+
+// Use in API validation
+const validated = insertUserSchema.parse(requestBody);
+```
+
+## Migrations with drizzle-kit
+
+```bash
+# Generate migration
+npx drizzle-kit generate
+
+# Push directly to database (dev only)
+npx drizzle-kit push
+
+# Apply migrations
+npx drizzle-kit migrate
+```
+
+### drizzle.config.ts
+
+```typescript
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  schema: "./src/db/schema/index.ts",
+  out: "./src/db/migrations",
+  dialect: "postgresql",
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+});
+```

package/templates/cursor/rules/fastify.mdc

@@ -0,0 +1,132 @@
+---
+description: Fastify conventions for TypeScript APIs
+globs: ["**/fastify/**/*.ts", "**/server/**/*.ts", "**/api/**/*.ts"]
+---
+
+# Fastify Conventions
+
+## Project Structure
+
+For simple APIs, use single-file structure:
+
+```
+src/
+├── index.ts          # Server setup + all routes
+├── config.ts         # Environment variables
+├── utils.ts          # Helpers, error handling
+└── types.ts          # Zod schemas + types
+```
+
+For larger APIs, organize by feature:
+```
+src/
+├── index.ts          # Server setup
+├── routes/
+│   ├── users.ts
+│   └── posts.ts
+├── config.ts
+└── utils.ts
+```
+
+## Server Setup
+
+```typescript
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+import {
+  serializerCompiler,
+  validatorCompiler,
+  ZodTypeProvider,
+} from "fastify-type-provider-zod";
+
+const app = Fastify({ logger: true }).withTypeProvider<ZodTypeProvider>();
+
+// Zod validation
+app.setValidatorCompiler(validatorCompiler);
+app.setSerializerCompiler(serializerCompiler);
+
+// Middleware
+await app.register(cors, { origin: true });
+
+// Routes go here...
+
+// Start server
+const port = Number(process.env.PORT) || 3000;
+app.listen({ port, host: "0.0.0.0" }, (err) => {
+  if (err) {
+    app.log.error(err);
+    process.exit(1);
+  }
+});
+```
+
+## Route Definitions with Zod
+
+```typescript
+import { z } from "zod";
+
+// Define schemas
+const CreateUserSchema = z.object({
+  name: z.string().min(1),
+  email: z.string().email(),
+});
+
+const UserResponseSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string(),
+});
+
+// Route with validation
+app.post(
+  "/users",
+  {
+    schema: {
+      body: CreateUserSchema,
+      response: { 201: UserResponseSchema },
+    },
+  },
+  async (request, reply) => {
+    const { name, email } = request.body; // Fully typed!
+    const user = await createUser({ name, email });
+    return reply.status(201).send(user);
+  }
+);
+```
+
+## Error Handling
+
+```typescript
+// Custom error handler
+app.setErrorHandler((error, request, reply) => {
+  app.log.error(error);
+  
+  if (error.validation) {
+    return reply.status(400).send({
+      error: "Validation Error",
+      details: error.validation,
+    });
+  }
+  
+  return reply.status(500).send({
+    error: "Internal Server Error",
+  });
+});
+```
+
+## Logging
+
+Use Fastify's built-in logger:
+```typescript
+app.log.info("[users] Creating user");
+app.log.error("[users] Failed to create user:", error);
+```
+
+## Health Check
+
+Always include a health endpoint:
+```typescript
+app.get("/health", async () => {
+  return { status: "ok" };
+});
+```

package/templates/cursor/rules/general.mdc

@@ -0,0 +1,112 @@
+---
+description: General coding conventions
+globs: ["**/*"]
+---
+
+# General Conventions
+
+## Dependencies & Libraries
+
+ALWAYS use the latest stable versions of libraries. Never suggest outdated packages.
+
+### When adding dependencies:
+
+- Use `npm install <package>` or `pip install <package>` without pinning old versions
+- If a package.json or requirements.txt exists, check current versions before suggesting additions
+- Prefer actively maintained packages over abandoned ones
+
+### Outdated patterns to AVOID:
+
+- `create-react-app` → Use Next.js or Vite instead
+- `moment.js` → Use `date-fns` or native `Intl`
+- `request` → Use native `fetch` or `axios`
+- Class components in React → Use functional components with hooks
+- `var` in JavaScript → Use `const`/`let`
+- Callback patterns → Use async/await
+- Express.js for new projects → Use Fastify (faster, better TS support)
+
+### When unsure about current best practices:
+
+- Check the official documentation
+- Verify the package's last publish date on npm/PyPI
+- Prefer packages with recent activity (< 6 months since last update)
+
+## Environment Variables
+
+ALWAYS use dotenv for environment variable management:
+
+### TypeScript/Node.js:
+
+- Use `dotenv` package or framework built-in (Next.js, Vite have it)
+- Create `.env.example` with all required vars (no secrets)
+- Never commit `.env` files (ensure in .gitignore)
+
+### Python:
+
+- Use `python-dotenv` package
+- Load with `load_dotenv()` at app entry point
+- Create `.env.example` template
+
+### Naming convention:
+
+- UPPERCASE_WITH_UNDERSCORES
+- Prefix with service name for clarity: `DATABASE_URL`, `REDIS_URL`, `API_SECRET_KEY`
+
+## Multi-Service Applications
+
+Use Docker Compose for complex apps with multiple services:
+
+### When to use Docker Compose:
+
+- 2+ services that communicate (API + DB, frontend + backend + cache)
+- Local development environment setup
+- Integration testing
+
+### Best practices:
+
+- Use `env_file` to load .env
+- Define `depends_on` for service ordering
+- Use named volumes for persistence
+- Include health checks for production-like setups
+
+## Tooling
+
+Run linters before committing:
+- TypeScript: `npm run check` (Biome)
+- Python: `ruff check --fix . && ruff format .`
+
+## Comments
+
+- Add comments **liberally** to help future readers
+- Explain WHY and provide context, not WHAT
+- JSDoc/docstrings only when behavior is non-obvious
+- File headers only on entry files (index.ts, app.py, main.py)
+
+## Logging
+
+Always prefix logs with module name in brackets:
+```
+console.log("[storage] Creating bucket");
+print("[handler] Processing request")
+```
+
+## Error Handling
+
+- **Early return** for validation errors
+- **Try-catch** for external operations (API calls, file I/O)
+- Use SDK error mapping utilities when available
+
+## Async
+
+- Always use async/await
+- Never use .then() chains
+
+## Naming
+
+- Use balanced verbosity: `accountStatus` not `s` or `userAccountStatusFromDatabase`
+- Constants: `SCREAMING_SNAKE_CASE`
+
+## References
+
+- [STYLE_GUIDE.md](../../STYLE_GUIDE.md) - Full conventions
+- [LINTING_SETUP.md](../../LINTING_SETUP.md) - Biome/Ruff setup

package/templates/cursor/rules/nextjs.mdc

@@ -0,0 +1,89 @@
+---
+description: Next.js conventions for App Router projects
+globs: ["**/app/**/*.tsx", "**/app/**/*.ts", "**/components/**/*.tsx"]
+---
+
+# Next.js Conventions
+
+## Project Structure
+
+Use App Router (`app/` directory):
+```
+app/
+├── layout.tsx        # Root layout
+├── page.tsx          # Home page
+├── globals.css       # Global styles
+├── api/              # Route handlers
+│   └── [route]/route.ts
+├── [feature]/        # Feature routes
+│   ├── page.tsx
+│   └── components/   # Route-specific components
+└── components/       # Shared components (or use /components at root)
+```
+
+## Server vs Client Components
+
+Always be **explicit** about component type:
+
+```tsx
+// Server Component (default) - add comment for clarity
+// server component
+export default async function UserList() {
+  const users = await fetchUsers(); // Can use async/await directly
+  return <ul>{users.map(u => <li key={u.id}>{u.name}</li>)}</ul>;
+}
+```
+
+```tsx
+// Client Component - must have 'use client' directive
+"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 Client Components
+
+Add `"use client"` only when you need:
+- React hooks (`useState`, `useEffect`, etc.)
+- Browser APIs (`window`, `document`, etc.)
+- Event handlers (`onClick`, `onChange`, etc.)
+- Third-party client libraries
+
+## Route Handlers (API Routes)
+
+```typescript
+// app/api/users/route.ts
+import { NextRequest, NextResponse } from "next/server";
+
+export async function GET(request: NextRequest) {
+  const users = await fetchUsers();
+  return NextResponse.json(users);
+}
+
+export async function POST(request: NextRequest) {
+  const body = await request.json();
+  // Validate with zod
+  const result = await createUser(body);
+  return NextResponse.json(result, { status: 201 });
+}
+```
+
+## Data Fetching
+
+- Use `fetch` in Server Components (auto-cached)
+- Use Server Actions for mutations
+- Use TanStack Query or SWR for client-side fetching only when necessary
+
+## File Naming
+
+- `page.tsx` - Route page
+- `layout.tsx` - Shared layout
+- `loading.tsx` - Loading UI
+- `error.tsx` - Error boundary
+- `not-found.tsx` - 404 page
+- Components: `PascalCase.tsx` (e.g., `UserCard.tsx`)

package/templates/cursor/rules/python.mdc

@@ -0,0 +1,89 @@
+---
+description: Python-specific conventions
+globs: ["**/*.py"]
+---
+
+# Python Conventions
+
+## Functions
+
+Use regular function definitions:
+```python
+# Good
+def handle_request(request: Request) -> Response:
+    ...
+
+async def fetch_user_data(user_id: str) -> User:
+    ...
+```
+
+Docstrings only when behavior is non-obvious:
+```python
+def fetch_blog_title(url: str) -> str:
+    """Fetch title, trying og:title, twitter:title, then <title> tag."""
+    ...
+```
+
+## Naming
+
+- Variables/functions: `snake_case`
+- Classes: `PascalCase`
+- Constants: `SCREAMING_SNAKE_CASE`
+
+## Type Validation with Pydantic
+
+Use Pydantic for runtime validation of external data:
+
+```python
+from pydantic import BaseModel, EmailStr
+
+class CreateUserRequest(BaseModel):
+    name: str
+    email: EmailStr
+    age: int | None = None
+
+# In FastAPI route
+@app.post("/users")
+async def create_user(request: CreateUserRequest):
+    # request is already validated and typed
+    return {"name": request.name, "email": request.email}
+```
+
+### When to Use Pydantic
+
+- API request/response bodies
+- Environment variables (pydantic-settings)
+- Configuration files
+- External API responses
+
+## Error Handling
+
+```python
+from fastapi import HTTPException
+
+try:
+    result = await api_call()
+    return result
+except Exception as e:
+    print(f"[module] Error: {e}")
+    raise HTTPException(status_code=500, detail="Internal server error")
+```
+
+## Project Structure
+
+```
+project/
+├── app.py        # Entry point: FastAPI app, middleware, routes
+├── config.py     # Environment variables, Pydantic models
+├── handlers.py   # Route handlers (business logic)
+├── utils.py      # Helpers, error mapping
+└── [feature].py  # Feature modules
+```
+
+## Linting
+
+Run before committing:
+```bash
+ruff check --fix .
+ruff format .
+```