render-create 0.1.0

package/templates/cursor/rules/vite.mdc

@@ -0,0 +1,169 @@
+---
+description: Vite + React SPA conventions
+globs: ["**/vite.config.*", "**/src/**/*.tsx", "**/src/**/*.ts"]
+---
+
+# Vite + React SPA Conventions
+
+## When to Use Vite vs Next.js
+
+**Use Vite when:**
+- Building a pure SPA (no SSR needed)
+- API is separate (backend in different service)
+- Simple static site or dashboard
+- Maximum build speed
+
+**Use Next.js when:**
+- Need SSR or static generation
+- SEO is important
+- Full-stack with API routes
+- Complex routing needs
+
+## Project Structure
+
+```
+src/
+├── main.tsx          # Entry point
+├── App.tsx           # Root component
+├── index.css         # Global styles (Tailwind)
+├── components/       # Reusable components
+│   ├── ui/           # Base UI components
+│   └── features/     # Feature-specific components
+├── hooks/            # Custom hooks
+├── lib/              # Utilities
+│   └── utils.ts      # cn() and helpers
+├── types/            # TypeScript types
+└── assets/           # Static assets
+```
+
+## Vite Configuration
+
+```typescript
+// vite.config.ts
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import path from "path";
+
+export default defineConfig({
+  plugins: [react()],
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  },
+  server: {
+    port: 3000,
+    proxy: {
+      "/api": {
+        target: "http://localhost:8080",
+        changeOrigin: true,
+      },
+    },
+  },
+});
+```
+
+## Path Aliases
+
+```json
+// tsconfig.json
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}
+```
+
+Usage:
+```typescript
+import { Button } from "@/components/ui/Button";
+import { useAuth } from "@/hooks/useAuth";
+```
+
+## Environment Variables
+
+```bash
+# .env
+VITE_API_URL=http://localhost:8080
+VITE_APP_NAME=My App
+```
+
+```typescript
+// Access in code - must be prefixed with VITE_
+const apiUrl = import.meta.env.VITE_API_URL;
+
+// Type definitions
+// src/vite-env.d.ts
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+  readonly VITE_API_URL: string;
+  readonly VITE_APP_NAME: string;
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv;
+}
+```
+
+## Entry Point
+
+```tsx
+// main.tsx
+import React from "react";
+import ReactDOM from "react-dom/client";
+import App from "./App";
+import "./index.css";
+
+ReactDOM.createRoot(document.getElementById("root")!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+);
+```
+
+## API Calls
+
+```typescript
+// lib/api.ts
+const API_URL = import.meta.env.VITE_API_URL;
+
+export async function fetchData<T>(endpoint: string): Promise<T> {
+  const response = await fetch(`${API_URL}${endpoint}`);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}`);
+  }
+  return response.json();
+}
+```
+
+## Scripts
+
+```json
+// package.json
+{
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview",
+    "lint": "biome check --write src/"
+  }
+}
+```
+
+## Build Output
+
+```bash
+# Build for production
+npm run build
+
+# Output in dist/
+dist/
+├── index.html
+├── assets/
+│   ├── index-[hash].js
+│   └── index-[hash].css
+```

package/templates/cursor/rules/workflows.mdc

@@ -0,0 +1,349 @@
+---
+description: Render Workflows conventions for distributed task execution
+globs: ["**/workflow/**/*.ts", "**/workflow/**/*.py", "**/workflows/**/*.ts", "**/workflows/**/*.py", "**/worker/**/*.ts", "**/worker/**/*.py"]
+---
+
+# Render Workflows Conventions
+
+Render Workflows provide managed execution of distributed tasks with rapid spin-up and automatic retries. Use workflows for ETL pipelines, AI agents, or any job that benefits from distributed background execution.
+
+## SDK Installation
+
+TypeScript:
+```bash
+npm install @renderinc/sdk
+```
+
+Python:
+```bash
+pip install render_sdk
+```
+
+## Project Structure
+
+TypeScript:
+```
+workflow/
+├── src/
+│   ├── tasks/
+│   │   ├── index.ts      # Task exports
+│   │   ├── math.ts       # Domain-specific tasks
+│   │   └── data.ts       # Data processing tasks
+│   └── main.ts           # Entry point
+├── package.json
+└── tsconfig.json
+```
+
+Python:
+```
+workflow/
+├── tasks/
+│   ├── __init__.py
+│   ├── math.py           # Domain-specific tasks
+│   └── data.py           # Data processing tasks
+├── main.py               # Entry point
+└── requirements.txt
+```
+
+## Defining Tasks
+
+### TypeScript
+
+```typescript
+import "dotenv/config";
+import { task, type Retry } from "@renderinc/sdk/workflows";
+
+// Retry configuration
+const retry: Retry = {
+  maxRetries: 3,
+  waitDurationMs: 1000,
+  factor: 1.5,
+};
+
+// Subtask: assign to const (called by other tasks)
+const square = task({ name: "square" }, function square(a: number): number {
+  console.log(`Calculating square of ${a}`);
+  return a * a;
+});
+
+// Root task: don't assign to variable
+task(
+  {
+    name: "processData",
+    timeoutSeconds: 300,
+    retry,
+  },
+  async function processData(input: string): Promise<string> {
+    return input.toUpperCase();
+  }
+);
+
+// Root task that calls subtasks
+task(
+  { name: "addSquares", timeoutSeconds: 300, retry },
+  async function addSquares(a: number, b: number): Promise<number> {
+    const result1 = await square(a);
+    const result2 = await square(b);
+    return result1 + result2;
+  }
+);
+```
+
+### Python
+
+```python
+import asyncio
+import logging
+
+from dotenv import load_dotenv
+from render_sdk import Retry, Workflows
+
+load_dotenv()
+
+logger = logging.getLogger(__name__)
+
+# Retry configuration
+retry = Retry(max_retries=3, wait_duration_ms=1000, backoff_scaling=1.5)
+
+# Initialize Workflows app
+app = Workflows(
+    default_retry=retry,
+    default_timeout=300,
+    auto_start=True,
+)
+
+# Subtask (called by other tasks)
+@app.task
+def square(a: int) -> int:
+    """Square a number."""
+    return a * a
+
+# Root task that calls subtasks
+@app.task
+async def add_squares(a: int, b: int) -> int:
+    """Add the squares of two numbers."""
+    result1 = await square(a)
+    result2 = await square(b)
+    return result1 + result2
+
+@app.task
+async def process_data(data: str) -> str:
+    """Process data."""
+    return data.upper()
+
+# Fan-out pattern
+@app.task
+async def fan_out(items: list[str]) -> list[str]:
+    """Process items in parallel."""
+    tasks = [process_data(item) for item in items]
+    results = await asyncio.gather(*tasks)
+    return list(results)
+```
+
+## Running Tasks (Client)
+
+### TypeScript
+
+```typescript
+import { Render, ClientError, ServerError, AbortError } from "@renderinc/sdk";
+
+const render = new Render();  // Uses RENDER_API_KEY env var
+
+async function runWorkflow() {
+  try {
+    // Run task and wait for completion
+    const result = await render.workflows.runTask(
+      "my-workflow/process-data",
+      ["input-value"]
+    );
+    
+    console.log("Status:", result.status);
+    console.log("Results:", result.results);
+    
+    // List recent task runs
+    const runs = await render.workflows.listTaskRuns({ limit: 10 });
+    
+    // Get specific task run details
+    const details = await render.workflows.getTaskRun(result.id);
+    
+  } catch (error) {
+    if (error instanceof ClientError) {
+      console.error("Client error:", error.statusCode);
+    } else if (error instanceof ServerError) {
+      console.error("Server error:", error.statusCode);
+    } else if (error instanceof AbortError) {
+      console.error("Request aborted");
+    }
+  }
+}
+```
+
+### Python
+
+```python
+import asyncio
+from render_sdk import Render
+from render_sdk.client import ListTaskRunsParams
+from render_sdk.client.errors import RenderError, TaskRunError
+
+async def run_workflow():
+    render = Render()  # Uses RENDER_API_KEY env var
+    
+    try:
+        # Run task and get awaitable result
+        task_run = await render.workflows.run_task(
+            "my-workflow/process-data",
+            {"arg1": "value"}
+        )
+        print(f"Task started: {task_run.id}")
+        
+        # Wait for completion
+        result = await task_run
+        print(f"Status: {result.status}")
+        print(f"Results: {result.results}")
+        
+        # List recent task runs
+        params = ListTaskRunsParams(limit=10)
+        runs = await render.workflows.list_task_runs(params)
+        
+    except TaskRunError as e:
+        print(f"Task failed: {e}")
+    except RenderError as e:
+        print(f"API error: {e}")
+
+asyncio.run(run_workflow())
+```
+
+## Best Practices
+
+### Task Design
+
+1. **Keep tasks focused**: Each task should do one thing well
+2. **Use subtasks for parallelism**: Fan out work across multiple instances
+3. **Make tasks idempotent**: Tasks may retry, so handle duplicate execution
+4. **Return JSON-serializable data**: All inputs and outputs must be JSON-compatible
+
+### Retry Configuration
+
+Import and type your retry config:
+
+```typescript
+import { task, type Retry } from "@renderinc/sdk/workflows";
+
+// Retry configuration
+const retry: Retry = {
+  maxRetries: 3,
+  waitDurationMs: 1000,
+  factor: 1.5,  // Exponential backoff: 1s, 1.5s, 2.25s
+};
+
+task(
+  { name: "fetchData", timeoutSeconds: 300, retry },
+  async function fetchData(url: string) {
+    const response = await fetch(url);
+    return response.json();
+  }
+);
+
+// For non-idempotent operations, disable retries
+task(
+  { name: "sendEmail", retry: { maxRetries: 0, waitDurationMs: 0 } },
+  async function sendEmail(to: string, subject: string) {
+    // Don't retry to avoid duplicates
+  }
+);
+```
+
+### Parallelizing Subtasks
+
+TypeScript:
+```typescript
+task(
+  { name: "processImages" },
+  async function processImages(urls: string[]): Promise<string[]> {
+    // Run all subtasks in parallel
+    const results = await Promise.all(
+      urls.map(url => processImage(url))
+    );
+    return results;
+  }
+);
+```
+
+Python:
+```python
+@app.task
+async def process_images(urls: list[str]) -> list[str]:
+    """Process multiple images in parallel."""
+    tasks = [process_image(url) for url in urls]
+    results = await asyncio.gather(*tasks)
+    return list(results)
+```
+
+### Error Handling
+
+```typescript
+task(
+  { name: "robustTask" },
+  async function robustTask(data: unknown): Promise<Result> {
+    try {
+      // Main logic
+      return await processData(data);
+    } catch (error) {
+      // Log for observability
+      console.error("Task failed:", error);
+      
+      // Re-throw to trigger retry (if configured)
+      throw error;
+    }
+  }
+);
+```
+
+### Cancellation Support (TypeScript)
+
+```typescript
+const render = new Render();
+const controller = new AbortController();
+
+// Cancel after timeout
+setTimeout(() => controller.abort(), 30000);
+
+try {
+  const result = await render.workflows.runTask(
+    "my-workflow/long-task",
+    [data],
+    controller.signal
+  );
+} catch (error) {
+  if (error instanceof AbortError) {
+    console.log("Task cancelled");
+  }
+}
+```
+
+## Environment Variables
+
+Required:
+- `RENDER_API_KEY` - Your Render API key
+
+Optional:
+- `RENDER_USE_LOCAL_DEV` - Enable local development mode (`true`/`false`)
+- `RENDER_LOCAL_DEV_URL` - Local dev URL (default: `http://localhost:8120`)
+
+## Task Identifier Format
+
+Tasks are identified by: `{workflow-slug}/{task-name}`
+
+Example: `my-workflow/process-data`
+
+The workflow slug comes from your Render Dashboard. The task name is either:
+- The function name (default)
+- A custom name specified in task options
+
+## Limitations
+
+- Task instances can run for up to 2 hours
+- Task instances cannot receive incoming network connections
+- All task arguments and return values must be JSON-serializable
+- Workflows currently require early access from Render

package/templates/docker-compose.example.yml

@@ -0,0 +1,55 @@
+version: '3.8'
+
+services:
+  api:
+    build: .
+    ports:
+      - "3000:3000"
+    env_file:
+      - .env
+    depends_on:
+      db:
+        condition: service_healthy
+    restart: unless-stopped
+
+  db:
+    image: postgres:16-alpine
+    ports:
+      - "5432:5432"
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: app
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+  # Uncomment for Redis
+  # redis:
+  #   image: redis:7-alpine
+  #   ports:
+  #     - "6379:6379"
+  #   volumes:
+  #     - redis_data:/data
+
+  # Uncomment for MinIO (S3-compatible storage)
+  # minio:
+  #   image: minio/minio
+  #   ports:
+  #     - "9000:9000"
+  #     - "9001:9001"
+  #   environment:
+  #     MINIO_ROOT_USER: minioadmin
+  #     MINIO_ROOT_PASSWORD: minioadmin
+  #   volumes:
+  #     - minio_data:/data
+  #   command: server /data --console-address ":9001"
+
+volumes:
+  postgres_data:
+  # redis_data:
+  # minio_data:

package/templates/drizzle/db-index.ts

@@ -0,0 +1,15 @@
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+import * as schema from "./schema";
+
+const connectionString = process.env.DATABASE_URL;
+
+// Create a placeholder client if DATABASE_URL is not set
+// This allows the app to start without a database for local development
+const client = connectionString
+  ? postgres(connectionString)
+  : postgres("postgres://placeholder:placeholder@localhost:5432/placeholder");
+
+export const db = drizzle(client, { schema });
+
+export const isDatabaseConfigured = !!connectionString;

package/templates/drizzle/drizzle.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  schema: "./src/db/schema.ts",
+  out: "./drizzle",
+  dialect: "postgresql",
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+});

package/templates/drizzle/schema.ts

@@ -0,0 +1,12 @@
+import { pgTable, serial, text, timestamp } from "drizzle-orm/pg-core";
+
+export const users = pgTable("users", {
+  id: serial("id").primaryKey(),
+  name: text("name").notNull(),
+  email: text("email").notNull().unique(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull(),
+});
+
+// Add more tables here as needed
+// export const posts = pgTable("posts", { ... });

package/templates/env.example

@@ -0,0 +1,15 @@
+# Application
+NODE_ENV=development
+PORT=3000
+
+# Database
+DATABASE_URL=postgresql://user:password@localhost:5432/dbname
+
+# External APIs
+# API_KEY=your-api-key-here
+
+# Storage (S3/MinIO)
+# S3_ENDPOINT=http://localhost:9000
+# S3_ACCESS_KEY=minioadmin
+# S3_SECRET_KEY=minioadmin
+# S3_BUCKET=uploads

package/templates/fastapi/app/__init__.py

@@ -0,0 +1 @@
+# App package

package/templates/fastapi/app/config.py

@@ -0,0 +1,12 @@
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    app_name: str = "{{PROJECT_NAME}}"
+    database_url: str = ""
+
+    class Config:
+        env_file = ".env"
+
+
+settings = Settings()

package/templates/fastapi/app/database.py

@@ -0,0 +1,16 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, declarative_base
+from app.config import settings
+
+engine = create_engine(settings.database_url)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

package/templates/fastapi/app/models.py

@@ -0,0 +1,13 @@
+from sqlalchemy import Column, Integer, String, DateTime
+from sqlalchemy.sql import func
+from app.database import Base
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String, nullable=False)
+    email = Column(String, unique=True, nullable=False, index=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())

package/templates/fastapi/main.py

@@ -0,0 +1,22 @@
+from fastapi import FastAPI
+from app.config import settings
+from app.database import engine
+from app import models
+
+# Create database tables
+models.Base.metadata.create_all(bind=engine)
+
+app = FastAPI(
+    title=settings.app_name,
+    version="0.1.0",
+)
+
+
+@app.get("/health")
+async def health_check():
+    return {"status": "ok"}
+
+
+@app.get("/")
+async def root():
+    return {"message": f"Welcome to {settings.app_name}"}