render-create 0.1.0

package/templates/vite/index.css

@@ -0,0 +1,127 @@
+@import "tailwindcss";
+@plugin "@tailwindcss/typography";
+
+/*
+ * Brutalist Design Defaults
+ * - Black background, white text
+ * - No rounded corners
+ * - High contrast borders
+ * - No gradients or shadows
+ */
+
+:root {
+  --background: #000000;
+  --foreground: #ffffff;
+  --border: #ffffff;
+  --muted: #888888;
+}
+
+* {
+  border-radius: 0 !important;
+}
+
+html {
+  color-scheme: dark;
+}
+
+body {
+  background: var(--background);
+  color: var(--foreground);
+  font-family: system-ui, -apple-system, sans-serif;
+  margin: 0;
+}
+
+/* Links */
+a {
+  color: var(--foreground);
+  text-decoration: underline;
+}
+
+a:hover {
+  text-decoration: none;
+}
+
+/* Buttons - brutalist style */
+button,
+[role="button"],
+input[type="submit"],
+input[type="button"] {
+  background: var(--foreground);
+  color: var(--background);
+  border: 1px solid var(--foreground);
+  padding: 0.75rem 1.5rem;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all 0.15s ease;
+}
+
+button:hover,
+[role="button"]:hover,
+input[type="submit"]:hover,
+input[type="button"]:hover {
+  background: transparent;
+  color: var(--foreground);
+}
+
+/* Secondary/outline buttons */
+button.secondary,
+.btn-secondary {
+  background: transparent;
+  color: var(--foreground);
+}
+
+button.secondary:hover,
+.btn-secondary:hover {
+  background: var(--foreground);
+  color: var(--background);
+}
+
+/* Inputs */
+input,
+textarea,
+select {
+  background: transparent;
+  border: 1px solid var(--foreground);
+  color: var(--foreground);
+  padding: 0.75rem;
+}
+
+input::placeholder,
+textarea::placeholder {
+  color: var(--muted);
+}
+
+input:focus,
+textarea:focus,
+select:focus {
+  outline: none;
+  border-color: var(--foreground);
+  box-shadow: 0 0 0 1px var(--foreground);
+}
+
+/* Cards/containers */
+.card,
+[class*="card"] {
+  background: transparent;
+  border: 1px solid var(--foreground);
+  padding: 1.5rem;
+}
+
+/* Typography - dark theme overrides */
+.prose {
+  --tw-prose-body: var(--foreground);
+  --tw-prose-headings: var(--foreground);
+  --tw-prose-links: var(--foreground);
+  --tw-prose-bold: var(--foreground);
+  --tw-prose-counters: var(--muted);
+  --tw-prose-bullets: var(--muted);
+  --tw-prose-hr: var(--foreground);
+  --tw-prose-quotes: var(--foreground);
+  --tw-prose-quote-borders: var(--foreground);
+  --tw-prose-captions: var(--muted);
+  --tw-prose-code: var(--foreground);
+  --tw-prose-pre-code: var(--foreground);
+  --tw-prose-pre-bg: rgba(255, 255, 255, 0.05);
+  --tw-prose-th-borders: var(--foreground);
+  --tw-prose-td-borders: var(--muted);
+}

package/templates/vite/vite.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import tailwindcss from "@tailwindcss/vite";
+
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+});

package/templates/worker/py/cron.py

@@ -0,0 +1,53 @@
+"""
+Cron Job
+
+Scheduled task that runs at specified intervals.
+Executes once and exits.
+"""
+
+import sys
+import time
+from datetime import datetime
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+def run_cron_job() -> None:
+    """Main cron job logic."""
+    start_time = time.time()
+    print(f"Cron job started at {datetime.now().isoformat()}")
+
+    try:
+        # TODO: Add your scheduled task logic here
+        # Examples:
+        # - Clean up old records
+        # - Send scheduled notifications
+        # - Generate reports
+        # - Sync data between systems
+
+        print("Executing scheduled task...")
+
+        # Placeholder: simulate work
+        time.sleep(1)
+
+        print("Scheduled task completed successfully")
+
+    except Exception as e:
+        print(f"Cron job failed: {e}")
+        raise
+
+    finally:
+        duration = time.time() - start_time
+        print(f"Cron job finished in {duration:.2f}s")
+
+
+if __name__ == "__main__":
+    try:
+        run_cron_job()
+        print("Cron job exiting successfully")
+        sys.exit(0)
+    except Exception as e:
+        print(f"Cron job exiting with error: {e}")
+        sys.exit(1)

package/templates/worker/py/worker.py

@@ -0,0 +1,95 @@
+"""
+Background Worker
+
+Long-running background process for async tasks.
+Runs continuously and processes work items.
+"""
+
+import os
+import signal
+import sys
+import time
+from dataclasses import dataclass
+from typing import Any
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+POLL_INTERVAL = 5  # seconds
+
+
+@dataclass
+class WorkItem:
+    id: str
+    data: Any
+
+
+# Graceful shutdown flag
+shutdown_requested = False
+
+
+def signal_handler(signum, frame):
+    """Handle shutdown signals gracefully."""
+    global shutdown_requested
+    print(f"Received signal {signum}, shutting down gracefully...")
+    shutdown_requested = True
+
+
+def process_work_item(item: WorkItem) -> None:
+    """Process a single work item."""
+    print(f"Processing work item: {item.id}")
+
+    # TODO: Add your processing logic here
+    # Example: fetch from queue, process data, update database
+
+    time.sleep(0.1)  # Simulate work
+
+    print(f"Completed work item: {item.id}")
+
+
+def fetch_work_items() -> list[WorkItem]:
+    """Fetch pending work items."""
+    # TODO: Implement your work item fetching logic
+    # Example: poll a database, queue, or API
+
+    # Placeholder: return empty list (no work)
+    return []
+
+
+def run_worker() -> None:
+    """Main worker loop."""
+    print("Worker started")
+    print(f"Poll interval: {POLL_INTERVAL}s")
+
+    while not shutdown_requested:
+        try:
+            items = fetch_work_items()
+
+            for item in items:
+                if shutdown_requested:
+                    break
+                process_work_item(item)
+
+            if not items:
+                # No work, wait before polling again
+                time.sleep(POLL_INTERVAL)
+
+        except Exception as e:
+            print(f"Worker error: {e}")
+            # Wait before retrying on error
+            time.sleep(POLL_INTERVAL)
+
+    print("Worker shutdown complete")
+
+
+if __name__ == "__main__":
+    # Register signal handlers
+    signal.signal(signal.SIGTERM, signal_handler)
+    signal.signal(signal.SIGINT, signal_handler)
+
+    try:
+        run_worker()
+    except Exception as e:
+        print(f"Fatal worker error: {e}")
+        sys.exit(1)

package/templates/worker/py/workflow.py

@@ -0,0 +1,73 @@
+"""
+Render Workflow
+
+Uses the Render SDK to define distributed tasks.
+See: https://pypi.org/project/render-sdk/
+"""
+
+import asyncio
+import logging
+
+from dotenv import load_dotenv
+from render_sdk import Retry, Workflows
+
+load_dotenv()
+
+logging.basicConfig(level=logging.INFO)
+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,
+)
+
+
+@app.task
+def square(a: int) -> int:
+    """Square a number (subtask)."""
+    logger.info(f"Computing square of {a}")
+    return a * a
+
+
+@app.task
+async def add_squares(a: int, b: int) -> int:
+    """Add the squares of two numbers using subtasks."""
+    logger.info(f"Computing add_squares: {a}, {b}")
+
+    result1 = await square(a)
+    result2 = await square(b)
+
+    total = result1 + result2
+    logger.info(f"Total: {total}")
+    return total
+
+
+@app.task
+async def process_data(data: str) -> str:
+    """Process data."""
+    logger.info(f"Processing data: {data}")
+
+    # TODO: Add your data processing logic here
+    result = data.upper()
+
+    logger.info(f"Processed result: {result}")
+    return result
+
+
+@app.task
+async def fan_out(items: list[str]) -> list[str]:
+    """Process multiple items in parallel using subtasks."""
+    logger.info(f"Processing {len(items)} items in parallel")
+
+    tasks = [process_data(item) for item in items]
+    results = await asyncio.gather(*tasks)
+
+    return list(results)
+
+
+# Task server starts automatically with auto_start=True

package/templates/worker/ts/cron.ts

@@ -0,0 +1,49 @@
+/**
+ * Cron Job
+ *
+ * Scheduled task that runs at specified intervals.
+ * Executes once and exits.
+ */
+
+import "dotenv/config";
+
+/**
+ * Main cron job logic
+ */
+async function runCronJob(): Promise<void> {
+  const startTime = Date.now();
+  console.log(`Cron job started at ${new Date().toISOString()}`);
+
+  try {
+    // TODO: Add your scheduled task logic here
+    // Examples:
+    // - Clean up old records
+    // - Send scheduled notifications
+    // - Generate reports
+    // - Sync data between systems
+
+    console.log("Executing scheduled task...");
+
+    // Placeholder: simulate work
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    console.log("Scheduled task completed successfully");
+  } catch (error) {
+    console.error("Cron job failed:", error);
+    throw error;
+  } finally {
+    const duration = Date.now() - startTime;
+    console.log(`Cron job finished in ${duration}ms`);
+  }
+}
+
+// Run the cron job
+runCronJob()
+  .then(() => {
+    console.log("Cron job exiting successfully");
+    process.exit(0);
+  })
+  .catch((error) => {
+    console.error("Cron job exiting with error:", error);
+    process.exit(1);
+  });

package/templates/worker/ts/worker.ts

@@ -0,0 +1,84 @@
+/**
+ * Background Worker
+ *
+ * Long-running background process for async tasks.
+ * Runs continuously and processes work items.
+ */
+
+import "dotenv/config";
+
+const POLL_INTERVAL = 5000; // 5 seconds
+
+interface WorkItem {
+  id: string;
+  data: unknown;
+}
+
+/**
+ * Process a single work item
+ */
+async function processWorkItem(item: WorkItem): Promise<void> {
+  console.log(`Processing work item: ${item.id}`);
+
+  // TODO: Add your processing logic here
+  // Example: fetch from queue, process data, update database
+
+  await new Promise((resolve) => setTimeout(resolve, 100)); // Simulate work
+
+  console.log(`Completed work item: ${item.id}`);
+}
+
+/**
+ * Fetch pending work items
+ */
+async function fetchWorkItems(): Promise<WorkItem[]> {
+  // TODO: Implement your work item fetching logic
+  // Example: poll a database, queue, or API
+
+  // Placeholder: return empty array (no work)
+  return [];
+}
+
+/**
+ * Main worker loop
+ */
+async function runWorker(): Promise<void> {
+  console.log("Worker started");
+  console.log(`Poll interval: ${POLL_INTERVAL}ms`);
+
+  while (true) {
+    try {
+      const items = await fetchWorkItems();
+
+      for (const item of items) {
+        await processWorkItem(item);
+      }
+
+      if (items.length === 0) {
+        // No work, wait before polling again
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+      }
+    } catch (error) {
+      console.error("Worker error:", error);
+      // Wait before retrying on error
+      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+    }
+  }
+}
+
+// Handle graceful shutdown
+process.on("SIGTERM", () => {
+  console.log("SIGTERM received, shutting down gracefully...");
+  process.exit(0);
+});
+
+process.on("SIGINT", () => {
+  console.log("SIGINT received, shutting down gracefully...");
+  process.exit(0);
+});
+
+// Start the worker
+runWorker().catch((error) => {
+  console.error("Fatal worker error:", error);
+  process.exit(1);
+});

package/templates/worker/ts/workflow.ts

@@ -0,0 +1,67 @@
+/**
+ * Render Workflow
+ *
+ * Uses the Render SDK to define distributed tasks.
+ * See: https://github.com/render-oss/sdk
+ */
+
+import "dotenv/config";
+import { task, type Retry } from "@renderinc/sdk/workflows";
+
+// Retry configuration
+const retry: Retry = {
+  maxRetries: 3,
+  waitDurationMs: 1000,
+  factor: 1.5,
+};
+
+/**
+ * Simple task that squares a number (subtask)
+ */
+const square = task({ name: "square" }, function square(a: number): number {
+  console.log(`Calculating square of ${a}`);
+  return a * a;
+});
+
+/**
+ * Async task that adds two squared numbers
+ */
+task(
+  {
+    name: "addSquares",
+    timeoutSeconds: 300,
+    retry,
+  },
+  async function addSquares(a: number, b: number): Promise<number> {
+    console.log(`Adding squares of ${a} and ${b}`);
+
+    const result1 = await square(a);
+    const result2 = await square(b);
+
+    const sum = result1 + result2;
+    console.log(`Result: ${result1} + ${result2} = ${sum}`);
+    return sum;
+  },
+);
+
+/**
+ * Task that processes data
+ */
+task(
+  {
+    name: "processData",
+    timeoutSeconds: 300,
+    retry,
+  },
+  async function processData(data: string): Promise<string> {
+    console.log(`Processing data: ${data}`);
+
+    // TODO: Add your data processing logic here
+    const result = data.toUpperCase();
+
+    console.log(`Processed result: ${result}`);
+    return result;
+  },
+);
+
+// Task server starts automatically when RENDER_SDK_SOCKET_PATH is set