@rebasepro/cli 0.0.1-canary.2 → 0.0.1-canary.4829d6e

package/templates/template/README.md

@@ -2,58 +2,125 @@
 
 A [Rebase](https://rebase.pro) project with a PostgreSQL backend.
 
-## Getting Started
+## Quick Start
 
-### Prerequisites
+### Option 1: Docker (recommended for production)
+
+```bash
+cp .env.example .env
+# Edit .env — set JWT_SECRET and DATABASE_URL (see comments for generators)
+
+docker compose up -d
+```
+
+That's it. Your app is running:
+- **Frontend**: http://localhost (port 80)
+- **Backend API**: http://localhost:3001
+- **PostgreSQL**: localhost:5432
+
+### Option 2: Local Development
+
+#### Prerequisites
 
 - [Node.js](https://nodejs.org) >= 18
-- [pnpm](https://pnpm.io)
-- A PostgreSQL database
+- [pnpm](https://pnpm.io) or [npm](https://www.npmjs.com) (v7+)
+- A PostgreSQL database (you can start the included database container via `docker compose up -d db`)
 
-### Setup
+#### Setup
 
 1. Install dependencies:
 
 ```bash
-pnpm install
+pnpm install   # or: npm install
 ```
 
-2. Configure your database — edit `.env` and set `DATABASE_URL`:
+2. Configure environment:
 
-```
-DATABASE_URL=postgresql://postgres:password@localhost:5432/mydb
+```bash
+cp .env.example .env
+# Edit .env — set DATABASE_URL, JWT_SECRET
 ```
 
-3. Generate and run database migrations:
+3. Generate schema and push to database:
 
 ```bash
-pnpm db:generate
-pnpm db:migrate
+pnpm run schema:generate   # or: npm run schema:generate
+pnpm run db:push            # or: npm run db:push
 ```
 
 4. Start the dev server:
 
 ```bash
-pnpm dev
+pnpm dev   # or: npm run dev
 ```
 
-This starts both the backend (Express + PostgreSQL on port 3001) and the frontend (Vite + React on port 5173) concurrently.
+Backend (Hono + PostgreSQL) on port 3001, frontend (Vite + React) on port 5173.
 
 ## Project Structure
 
 ```
-├── frontend/       # React frontend (Vite)
-├── backend/        # Express backend with PostgreSQL
-├── shared/         # Shared collection definitions
-├── .env            # Environment variables
-└── package.json    # Root workspace config
+├── frontend/           # React frontend (Vite)
+│   ├── Dockerfile      # Production build → nginx
+│   └── nginx.conf      # SPA routing + compression
+├── backend/            # Hono backend with PostgreSQL
+│   ├── Dockerfile      # Multi-stage production build
+│   ├── functions/      # Custom API endpoints (auto-discovered)
+│   └── src/
+├── config/             # Shared collection definitions
+│   └── collections/    # Schema-as-Code TypeScript files
+├── docker-compose.yml  # Production stack (Postgres + Backend + Frontend)
+├── .env.example        # Environment variable reference
+└── package.json        # Root workspace config
+```
+
+### Custom Functions
+
+Drop a Hono app in `backend/functions/` and it's auto-mounted at `/api/functions/<name>`:
+
+```typescript
+// backend/functions/hello.ts
+import { Hono } from "hono";
+const app = new Hono();
+app.post("/", async (c) => {
+    const body = await c.req.json();
+    return c.json({ message: `Hello, ${body.name}!` });
+});
+export default app;
 ```
 
+Call from the client SDK: `client.call("functions/hello", { name: "World" })`
+
 ### Shared Collections
 
-Collections are defined once in `shared/collections/` and used by both the frontend and backend. This ensures your schema stays in sync across the stack.
+Collections are defined once in `config/collections/` and used by both the frontend and backend. This ensures your schema stays in sync across the stack.
+
+## Environment Configuration
+
+All configuration is managed through a single `.env` file in the project root. Both the backend and frontend read from this file:
+
+- **Backend**: loads via `dotenv` from `../../.env` (relative to `backend/src/`)
+- **Frontend**: Vite reads `VITE_*` variables via `envDir` pointing to the project root
+- **Scripts**: load via `dotenv` from the project root
+
+Copy `.env.example` to `.env` to get started. See the comments in `.env.example` for details on each variable.
+
+## Production Deployment
+
+```bash
+# Build and start
+docker compose up -d --build
+
+# View logs
+docker compose logs -f backend
+
+# Stop
+docker compose down
+
+# Stop and remove data
+docker compose down -v
+```
 
 ## Documentation
 
 - [Rebase Docs](https://rebase.pro/docs)
-- [GitHub](https://github.com/rebaseco/rebase)
+- [GitHub](https://github.com/rebasepro/rebase)

package/templates/template/ai-instructions.md

@@ -0,0 +1,17 @@
+# Rebase AI Coding Rules
+
+Rebase provides agent skills for AI coding assistants (Cursor, Claude Code, Windsurf, Gemini CLI, Antigravity, and more) with detailed guidelines, architecture, SDK APIs, and troubleshooting guides.
+
+To install skills for your environment, run:
+
+```
+rebase skills install
+```
+
+## Core Tenets (Quick Reference)
+
+1. **Schema-as-Code**: Always define or edit collections in `config/collections/` (e.g., `config/collections/posts.ts`). Never modify generated Drizzle schemas or PostgreSQL tables manually.
+2. **Two-Step Migrations**:
+   - Step 1: Run `rebase schema generate` to compile collections to the Drizzle schema.
+   - Step 2: Run `rebase db push` (development) or `rebase db generate && rebase db migrate` (production) to apply schema changes to the database.
+3. **Use the SDK**: Always use the Rebase SDK (`rebase.data.<slug>`) to fetch or modify data. Bypassing it with raw SQL or direct Drizzle/PG queries circumvents model validations, lifecycle hooks, and Row-Level Security (RLS).

package/templates/template/backend/Dockerfile

@@ -1,25 +1,71 @@
-FROM node:24-alpine AS base
+# ─── Multi-stage production Dockerfile for the Rebase backend ─────────
+# Produces a minimal image (~150MB) with only the runtime needed.
+#
+# Build context: the project root (where pnpm-workspace.yaml lives)
+# Usage:
+#   docker build -t my-app-backend -f backend/Dockerfile .
+#   docker run -p 3001:3001 --env-file .env my-app-backend
+
+# ── Stage 1: Install + Build ─────────────────────────────────────────
+FROM node:22-alpine AS builder
+
 ENV PNPM_HOME="/pnpm"
 ENV PATH="$PNPM_HOME:$PATH"
 RUN corepack enable
-RUN apk add --no-cache python3 make g++
+
+# Native dependencies for bcrypt, pg, etc.
+RUN apk add --no-cache python3 make g++ curl ca-certificates
 
 WORKDIR /app
 
-# Copy root configurations
-COPY package.json ./
+# Copy workspace root files first (cache-friendly layer)
+COPY package.json pnpm-lock.yaml pnpm-workspace.yaml .npmrc ./
 
-# Copy internal workspaces
+# Copy workspace packages
 COPY backend ./backend
-COPY shared ./shared
+COPY config ./config
+
+# Install all deps (including devDependencies for build)
+RUN pnpm install --frozen-lockfile
+
+# Build config first, then backend
+RUN pnpm --filter "*-config" run build
+RUN pnpm --filter "*-backend" run build
+
+# Prune dev dependencies for a smaller runtime
+RUN CI=true pnpm install --frozen-lockfile --prod
+
+# ── Stage 2: Production Runtime ──────────────────────────────────────
+FROM node:22-alpine AS runtime
+
+ENV PNPM_HOME="/pnpm"
+ENV PATH="$PNPM_HOME:$PATH"
+ENV NODE_ENV=production
+ENV CI=true
+
+RUN corepack enable
 
-# Install dependencies
-RUN pnpm install
+# Security: run as non-root
+RUN addgroup -g 1001 rebase && adduser -u 1001 -G rebase -s /bin/sh -D rebase
+
+WORKDIR /app
 
-# Build shared and backend
-RUN pnpm run build:shared
-RUN pnpm run build:backend
+# Copy only production artifacts
+COPY --from=builder /app/package.json /app/pnpm-lock.yaml /app/pnpm-workspace.yaml /app/.npmrc ./
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/backend ./backend
+COPY --from=builder /app/config ./config
+
+# Create uploads directory
+RUN mkdir -p /app/backend/uploads && chown -R rebase:rebase /app
+
+USER rebase
 
 WORKDIR /app/backend
 EXPOSE 3001
+
+# Health check for orchestrators (Docker Compose, ECS, k8s)
+HEALTHCHECK --interval=30s --timeout=5s --retries=3 --start-period=10s \
+    CMD wget --no-verbose --tries=1 --spider http://localhost:3001/health || exit 1
+
 CMD ["pnpm", "start"]

package/templates/template/backend/functions/hello.ts

@@ -0,0 +1,56 @@
+import { defineFunction } from "@rebasepro/server";
+
+/**
+ * Example custom function route.
+ *
+ * This file is auto-discovered by Rebase and mounted at:
+ *   POST /api/functions/hello
+ *   GET  /api/functions/hello
+ *
+ * Call from the client SDK:
+ *   const result = await client.call("functions/hello", { name: "World" });
+ *
+ * Authored with `defineFunction`, which hands you a pre-typed Hono app
+ * (so `c.get("user")` / `c.get("driver")` are typed) and the `rebase`
+ * singleton via the injected context — use any Hono middleware, define any
+ * HTTP methods, access the request/response directly.
+ *
+ * `rebase.dataAsAdmin` gives you admin-level access to your data and
+ * **bypasses RLS** — use it only for trusted admin work. For request-scoped /
+ * RLS-scoped data access, use c.get("user") and c.get("driver"), which carry
+ * the caller's identity. (`rebase` also exposes auth, storage, email.)
+ */
+export default defineFunction((app, { rebase }) => {
+    void rebase; // available for dataAsAdmin/auth/storage/email — see commented usage below
+
+    app.post("/", async (c) => {
+        const body = await c.req.json().catch(() => ({}));
+        const user = c.get("user");
+
+        const userId = (user && typeof user === "object" && "userId" in user)
+            ? user.userId
+            : "anonymous";
+
+        // Access any Rebase service via the injected `rebase`:
+        // await rebase.email.send({
+        //     to: "admin@example.com",
+        //     subject: "Function called",
+        //     html: `<p>Hello from ${userId}!</p>`,
+        // });
+        //
+        // Admin-scoped data (bypasses RLS — trusted work only):
+        // const authors = await rebase.dataAsAdmin.authors.find({ limit: 5 });
+        // For user-scoped data (RLS applies), use the request-scoped driver
+        // (c.get("driver")), which carries the caller's identity.
+
+        return c.json({
+            message: `Hello, ${body.name || "World"}!`,
+            user: userId
+        });
+    });
+
+    app.get("/", (c) => {
+        return c.json({ status: "ok",
+            endpoint: "hello" });
+    });
+});

package/templates/template/backend/package.json

@@ -1,36 +1,32 @@
 {
-  "name": "{{PROJECT_NAME}}-backend",
-  "version": "1.0.0",
-  "description": "Rebase backend with PostgreSQL",
-  "main": "src/index.ts",
-  "type": "module",
-  "scripts": {
-    "dev": "tsx watch --watch=\"../shared/**/*\" src/index.ts",
-    "build": "tsc --noEmit",
-    "start": "tsx src/index.ts",
-    "generate:schema": "tsx node_modules/@rebasepro/backend/src/generate-drizzle-schema.ts --collections=../shared/collections --output=src/schema.generated.ts",
-    "db:generate": "pnpm generate:schema && tsx scripts/db-generate.ts",
-    "db:migrate": "DOTENV_CONFIG_PATH=../.env drizzle-kit migrate",
-    "db:push": "DOTENV_CONFIG_PATH=../.env drizzle-kit push",
-    "db:studio": "DOTENV_CONFIG_PATH=../.env drizzle-kit studio"
-  },
-  "dependencies": {
-    "{{PROJECT_NAME}}-shared": "workspace:*",
-    "@rebasepro/backend": "^4.0.0",
-    "cors": "^2.8.5",
-    "drizzle-orm": "^0.44.4",
-    "express": "^5.1.0",
-    "pg": "^8.11.3",
-    "ws": "^8.16.0",
-    "zod": "^3.22.4",
-    "dotenv": "^16.0.0"
-  },
-  "devDependencies": {
-    "@types/pg": "^8.6.5",
-    "@types/node": "^20.10.5",
-    "@types/ws": "^8.5.10",
-    "drizzle-kit": "^0.31.4",
-    "tsx": "^4.20.6",
-    "typescript": "^5.9.2"
-  }
+    "name": "{{PROJECT_NAME}}-backend",
+    "version": "1.0.0",
+    "description": "Rebase backend with PostgreSQL",
+    "main": "src/index.ts",
+    "type": "module",
+    "scripts": {
+        "dev": "tsx watch --watch=\"../config/**/*\" src/index.ts",
+        "build": "rebase schema generate --collections ../config/collections && tsc",
+        "start": "node dist/backend/src/index.js"
+    },
+    "dependencies": {
+        "{{PROJECT_NAME}}-config": "*",
+        "@rebasepro/server": "workspace:*",
+        "@rebasepro/server-postgres": "workspace:*",
+        "@rebasepro/types": "workspace:*",
+        "drizzle-orm": "^0.45.2",
+        "hono": "^4.12.10",
+        "@hono/node-server": "^1.19.12",
+        "pg": "^8.11.3",
+        "ws": "^8.16.0",
+        "dotenv": "^16.0.0",
+        "zod": "^4.4.3"
+    },
+    "devDependencies": {
+        "@types/pg": "^8.6.5",
+        "@types/node": "^20.10.5",
+        "@types/ws": "^8.5.10",
+        "tsx": "^4.20.6",
+        "typescript": "^5.9.2"
+    }
 }

package/templates/template/backend/src/env.ts

@@ -0,0 +1,23 @@
+import * as dotenv from "dotenv";
+import path from "path";
+import { fileURLToPath } from "url";
+import { loadEnv } from "@rebasepro/server";
+import { z } from "zod";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+dotenv.config({ path: path.resolve(__dirname, "../../.env") });
+
+export const env = loadEnv({
+    extend: z.object({
+        SMTP_HOST: z.string().optional(),
+        SMTP_PORT: z.string().default("587").transform(Number),
+        SMTP_SECURE: z.enum(["true", "false", ""]).default("false").transform(v => v === "true"),
+        SMTP_USER: z.string().optional(),
+        SMTP_PASS: z.string().optional(),
+        SMTP_FROM: z.string().optional(),
+        SMTP_NAME: z.string().optional(),
+        APP_NAME: z.string().default("Rebase")
+    })
+});