@rebasepro/cli 0.0.1-canary.1 → 0.0.1-canary.4d4fb3e

package/templates/template/backend/Dockerfile

@@ -1,25 +1,70 @@
-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:24-alpine AS builder
+
 ENV PNPM_HOME="/pnpm"
 ENV PATH="$PNPM_HOME:$PATH"
 RUN corepack enable
+
+# Native dependencies for bcrypt, pg, etc.
 RUN apk add --no-cache python3 make g++
 
 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 ./
 
-# Copy internal workspaces
+# Copy workspace packages
 COPY backend ./backend
 COPY shared ./shared
 
-# Install dependencies
-RUN pnpm install
+# Install all deps (including devDependencies for build)
+RUN pnpm install --frozen-lockfile
+
+# Build shared first, then backend
+RUN pnpm --filter "*-shared" run build
+RUN pnpm --filter "*-backend" run build
+
+# Prune dev dependencies for a smaller runtime
+RUN pnpm install --frozen-lockfile --prod
+
+# ── Stage 2: Production Runtime ──────────────────────────────────────
+FROM node:24-alpine AS runtime
+
+ENV PNPM_HOME="/pnpm"
+ENV PATH="$PNPM_HOME:$PATH"
+ENV NODE_ENV=production
+
+RUN corepack enable
+
+# 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 ./
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/backend ./backend
+COPY --from=builder /app/shared ./shared
+
+# 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,34 @@
+import { Hono } from "hono";
+
+/**
+ * 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" });
+ *
+ * This is a standard Hono app — use any Hono middleware,
+ * define any HTTP methods, access the request/response directly.
+ * The authenticated user and RLS-scoped driver are available
+ * via c.get("user") and c.get("driver").
+ */
+const app = new Hono();
+
+app.post("/", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const user = c.get("user") as any;
+
+    return c.json({
+        message: `Hello, ${body.name || "World"}!`,
+        user: user?.userId || "anonymous",
+    });
+});
+
+app.get("/", (c) => {
+    return c.json({ status: "ok", endpoint: "hello" });
+});
+
+export default app;

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=\"../shared/**/*\" src/index.ts",
+        "build": "tsc --noEmit",
+        "start": "tsx src/index.ts"
+    },
+    "dependencies": {
+        "{{PROJECT_NAME}}-shared": "0.0.1",
+        "@rebasepro/server-core": "workspace:*",
+        "@rebasepro/server-postgresql": "workspace:*",
+        "drizzle-orm": "^0.44.4",
+        "hono": "^4.2.0",
+        "@hono/node-server": "^1.11.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"
+    }
 }

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

@@ -1,128 +1,90 @@
-import express from "express";
-import cors from "cors";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { secureHeaders } from "hono/secure-headers";
+import { getRequestListener } from "@hono/node-server";
+import { createServer } from "http";
 import path from "path";
 import { fileURLToPath } from "url";
-import { createServer } from "http";
-import { createPostgresDatabaseConnection, initializeRebaseAPI, initializeRebaseBackend, serveSPA } from "@rebasepro/backend";
-
+import {
+    initializeRebaseBackend,
+    serveSPA,
+    HonoEnv
+} from "@rebasepro/server-core";
+import { createPostgresDatabaseConnection, createPostgresBootstrapper } from "@rebasepro/server-postgresql";
 import { enums, relations, tables } from "./schema.generated";
-
 import * as dotenv from "dotenv";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-// Load environment from project root
 dotenv.config({ path: path.resolve(__dirname, "../../.env") });
 
-const app = express();
-const server = createServer(app);
+// ─── App ─────────────────────────────────────────────────────────────
+const app = new Hono<HonoEnv>();
+
+app.use("/*", cors({
+    origin: process.env.NODE_ENV === "production"
+        ? [process.env.FRONTEND_URL || "https://yourdomain.com"]
+        : ["http://localhost:5173", "http://localhost:3000"],
+    credentials: true
+}));
 
-// PostgreSQL connection
+app.use("/*", secureHeaders());
+
+// ─── Database ────────────────────────────────────────────────────────
 const databaseUrl = process.env.DATABASE_URL;
-if (!databaseUrl) {
-    throw new Error("DATABASE_URL environment variable is not set");
-}
-const db = createPostgresDatabaseConnection(databaseUrl);
+if (!databaseUrl) throw new Error("DATABASE_URL is not set");
 
-// Middleware
-app.use(cors());
-app.use(express.json({ limit: "10mb" }));
+const { db, connectionString } = createPostgresDatabaseConnection(databaseUrl);
 
+// ─── Start ───────────────────────────────────────────────────────────
 async function startServer() {
     const jwtSecret = process.env.JWT_SECRET;
-    if (!jwtSecret) {
-        throw new Error("JWT_SECRET environment variable is not set");
-    }
+    if (!jwtSecret) throw new Error("JWT_SECRET is not set");
+
+    const PORT = parseInt(process.env.PORT || "3001", 10);
+    const server = createServer(getRequestListener(app.fetch));
 
-    // Initialize Rebase Backend with auth
     const backend = await initializeRebaseBackend({
         collectionsDir: path.resolve(__dirname, "../../shared/collections"),
+        functionsDir: path.resolve(__dirname, "../functions"),
         server,
         app,
-        datasource: {
-            "(default)": {
+        bootstrappers: [
+            createPostgresBootstrapper({
                 connection: db,
                 schema: { tables, enums, relations },
-                adminConnectionString: process.env.ADMIN_CONNECTION_STRING || process.env.DATABASE_URL
-            }
-        },
+                adminConnectionString: process.env.ADMIN_CONNECTION_STRING || databaseUrl,
+                connectionString
+            })
+        ],
         auth: {
             jwtSecret,
             accessExpiresIn: process.env.JWT_ACCESS_EXPIRES_IN || "1h",
             refreshExpiresIn: process.env.JWT_REFRESH_EXPIRES_IN || "30d",
-            google: process.env.GOOGLE_CLIENT_ID ? {
-                clientId: process.env.GOOGLE_CLIENT_ID
-            } : undefined,
+            google: process.env.GOOGLE_CLIENT_ID
+                ? { clientId: process.env.GOOGLE_CLIENT_ID }
+                : undefined,
             seedDefaultRoles: true,
-            allowRegistration: process.env.ALLOW_REGISTRATION === "true",
-            email: process.env.SMTP_HOST ? {
-                from: process.env.SMTP_FROM || "noreply@example.com",
-                appName: process.env.APP_NAME || "Rebase",
-                resetPasswordUrl: process.env.FRONTEND_URL || "http://localhost:5173",
-                verifyEmailUrl: process.env.FRONTEND_URL || "http://localhost:5173",
-                smtp: {
-                    host: process.env.SMTP_HOST,
-                    port: parseInt(process.env.SMTP_PORT || "587"),
-                    secure: process.env.SMTP_SECURE === "true",
-                    auth: process.env.SMTP_USER ? {
-                        user: process.env.SMTP_USER,
-                        pass: process.env.SMTP_PASS || ""
-                    } : undefined
-                }
-            } : undefined
+            allowRegistration: process.env.ALLOW_REGISTRATION === "true"
         },
         storage: {
             type: "local",
             basePath: path.resolve(__dirname, "../../uploads")
-        }
+        },
+        history: true,
     });
 
-    // Initialize REST/GraphQL API
-    await initializeRebaseAPI(app, backend, {
-        basePath: "/api",
-        collectionsDir: path.resolve(__dirname, "../../shared/collections"),
-        enableGraphQL: true,
-        enableREST: true,
-        cors: {
-            origin: true,
-            credentials: true
-        }
-    });
+    // ─── Your routes ─────────────────────────────────────────────
+    app.get("/health", (c) => c.json({ status: "ok" }));
 
-    // Serve SPA in production
+    // Serve the frontend in production
     if (process.env.NODE_ENV === "production") {
-        serveSPA(app, {
-            frontendPath: path.join(__dirname, "../../frontend/dist"),
-            excludePaths: ["/health"]
-        });
+        serveSPA(app, { frontendPath: path.join(__dirname, "../../frontend/dist") });
     }
 
-    app.get("/health", (req, res) => {
-        res.json({
-            status: "ok",
-            timestamp: new Date().toISOString(),
-            environment: process.env.NODE_ENV
-        });
-    });
-
-    // Error handling
-    app.use((error: Error, _req: express.Request, res: express.Response, _next: express.NextFunction) => {
-        console.error("Unhandled error:", error);
-        res.status(500).json({
-            error: "Internal server error",
-            message: error.message
-        });
-    });
-
-    const PORT = process.env.PORT || 3001;
-
     server.listen(PORT, () => {
         console.log(`🚀 Server running at http://localhost:${PORT}`);
-        console.log(`   • REST API: http://localhost:${PORT}/api`);
-        console.log(`   • GraphQL: http://localhost:${PORT}/api/graphql`);
-        console.log(`   • Swagger docs: http://localhost:${PORT}/api/swagger`);
-        console.log(`   • Health: http://localhost:${PORT}/health`);
     });
 }
 
@@ -131,4 +93,4 @@ startServer().catch(err => {
     process.exit(1);
 });
 
-export { app, server };
+export { app };

package/templates/template/docker-compose.yml

@@ -1,48 +1,97 @@
-version: '3.8'
+# ─── Rebase — Production Docker Compose ──────────────────────────────
+#
+# Quick start:
+#   cp .env.template .env    # Edit with your secrets
+#   docker compose up -d     # Start everything
+#
+# This runs:
+#   1. PostgreSQL 18 with persistent data
+#   2. Backend (Node.js / Hono) with health checks
+#   3. Frontend (nginx) serving the Vite build
+#
+# For development, use `pnpm dev` instead.
+# ─────────────────────────────────────────────────────────────────────
 
 services:
+  # ── PostgreSQL ───────────────────────────────────────────────────────
   db:
     image: postgres:18-alpine
+    restart: unless-stopped
     environment:
-      POSTGRES_USER: rebase
-      POSTGRES_PASSWORD: rebasepassword
-      POSTGRES_DB: rebase
+      POSTGRES_USER: ${POSTGRES_USER:-rebase}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
+      POSTGRES_DB: ${POSTGRES_DB:-rebase}
     ports:
-      - "5432:5432"
+      - "${POSTGRES_PORT:-5432}:5432"
     volumes:
       - postgres_data:/var/lib/postgresql/data
     healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U rebase"]
+      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-rebase} -d ${POSTGRES_DB:-rebase}"]
       interval: 5s
       timeout: 5s
-      retries: 5
+      retries: 10
+      start_period: 10s
+    # Production tuning (adjust for your workload)
+    command:
+      - "postgres"
+      - "-c" 
+      - "shared_buffers=256MB"
+      - "-c"
+      - "max_connections=100"
+      - "-c"
+      - "work_mem=4MB"
+      - "-c"
+      - "effective_cache_size=768MB"
+      - "-c"
+      - "log_min_duration_statement=1000"
 
+  # ── Backend ──────────────────────────────────────────────────────────
   backend:
-    build: 
+    build:
       context: .
       dockerfile: backend/Dockerfile
+    restart: unless-stopped
     ports:
-      - "3001:3001"
+      - "${PORT:-3001}:3001"
     environment:
-      - DATABASE_URL=postgresql://rebase:rebasepassword@db:5432/rebase
-      - JWT_SECRET=super-secret-jwt-key
-      - NODE_ENV=development
+      DATABASE_URL: postgresql://${POSTGRES_USER:-rebase}:${POSTGRES_PASSWORD}@db:5432/${POSTGRES_DB:-rebase}
+      ADMIN_CONNECTION_STRING: postgresql://${POSTGRES_USER:-rebase}:${POSTGRES_PASSWORD}@db:5432/${POSTGRES_DB:-rebase}
+      JWT_SECRET: ${JWT_SECRET:?Set JWT_SECRET in .env}
+      JWT_ACCESS_EXPIRES_IN: ${JWT_ACCESS_EXPIRES_IN:-1h}
+      JWT_REFRESH_EXPIRES_IN: ${JWT_REFRESH_EXPIRES_IN:-30d}
+      NODE_ENV: production
+      PORT: "3001"
+      ALLOW_REGISTRATION: ${ALLOW_REGISTRATION:-false}
+      FRONTEND_URL: ${FRONTEND_URL:-http://localhost}
+      # Optional Google OAuth
+      GOOGLE_CLIENT_ID: ${GOOGLE_CLIENT_ID:-}
+      # Optional SMTP
+      SMTP_HOST: ${SMTP_HOST:-}
+      SMTP_PORT: ${SMTP_PORT:-}
+      SMTP_SECURE: ${SMTP_SECURE:-}
+      SMTP_USER: ${SMTP_USER:-}
+      SMTP_PASS: ${SMTP_PASS:-}
+      SMTP_FROM: ${SMTP_FROM:-}
+      APP_NAME: ${APP_NAME:-Rebase}
     depends_on:
       db:
         condition: service_healthy
     volumes:
-      - ./backend/uploads:/app/backend/uploads
+      - uploads:/app/backend/uploads
 
+  # ── Frontend ─────────────────────────────────────────────────────────
   frontend:
     build:
       context: .
       dockerfile: frontend/Dockerfile
+    restart: unless-stopped
     ports:
-      - "5173:5173"
-    environment:
-      - VITE_API_URL=http://localhost:3001
+      - "${FRONTEND_PORT:-80}:80"
     depends_on:
       - backend
 
 volumes:
   postgres_data:
+    driver: local
+  uploads:
+    driver: local

package/templates/template/frontend/Dockerfile

@@ -1,28 +1,50 @@
-FROM node:24-alpine AS base
+# ─── Multi-stage production Dockerfile for the Rebase frontend ────────
+# Builds the Vite app, then serves via nginx for proper caching/compression.
+#
+# Build context: the project root (where pnpm-workspace.yaml lives)
+# Usage:
+#   docker build -t my-app-frontend -f frontend/Dockerfile .
+
+# ── Stage 1: Install + Build ─────────────────────────────────────────
+FROM node:24-alpine AS builder
+
 ENV PNPM_HOME="/pnpm"
 ENV PATH="$PNPM_HOME:$PATH"
 RUN corepack enable
+
 RUN apk add --no-cache python3 make g++
 
 WORKDIR /app
 
-# Copy root configurations
-COPY package.json ./
+# Copy workspace root files
+COPY package.json pnpm-lock.yaml pnpm-workspace.yaml ./
 
-# Copy internal workspaces
+# Copy workspace packages
 COPY frontend ./frontend
 COPY shared ./shared
 
 # Install dependencies
-RUN pnpm install
+RUN pnpm install --frozen-lockfile
+
+# Build shared first, then frontend
+RUN pnpm --filter "*-shared" run build
+RUN pnpm --filter "*-frontend" run build
+
+# ── Stage 2: Serve with nginx ────────────────────────────────────────
+FROM nginx:1.27-alpine AS runtime
+
+# Remove default nginx page
+RUN rm -rf /usr/share/nginx/html/*
+
+# Copy built assets
+COPY --from=builder /app/frontend/dist /usr/share/nginx/html
+
+# Custom nginx config for SPA routing + compression
+COPY frontend/nginx.conf /etc/nginx/conf.d/default.conf
 
-# Build shared and frontend
-RUN pnpm run build:shared
-RUN pnpm run build:frontend
+EXPOSE 80
 
-# Install a simple static server
-RUN npm install -g serve
+HEALTHCHECK --interval=30s --timeout=5s --retries=3 \
+    CMD wget --no-verbose --tries=1 --spider http://localhost:80/ || exit 1
 
-WORKDIR /app/frontend
-EXPOSE 5173
-CMD ["serve", "-s", "dist", "-l", "5173"]
+CMD ["nginx", "-g", "daemon off;"]

package/templates/template/frontend/nginx.conf

@@ -0,0 +1,40 @@
+server {
+    listen 80;
+    server_name _;
+
+    root /usr/share/nginx/html;
+    index index.html;
+
+    # Gzip compression
+    gzip on;
+    gzip_vary on;
+    gzip_proxied any;
+    gzip_comp_level 6;
+    gzip_min_length 256;
+    gzip_types
+        text/plain
+        text/css
+        text/javascript
+        application/javascript
+        application/json
+        application/xml
+        image/svg+xml
+        font/woff2;
+
+    # Cache static assets aggressively (hashed filenames from Vite)
+    location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
+        expires 1y;
+        add_header Cache-Control "public, immutable";
+        try_files $uri =404;
+    }
+
+    # SPA fallback: serve index.html for all non-file routes
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+
+    # Security headers
+    add_header X-Frame-Options "SAMEORIGIN" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header Referrer-Policy "strict-origin-when-cross-origin" always;
+}

package/templates/template/frontend/package.json

@@ -4,17 +4,16 @@
     "private": true,
     "type": "module",
     "dependencies": {
-        "@rebasepro/auth": "^4.0.0",
-        "@rebasepro/core": "^4.0.0",
-        "@rebasepro/data_enhancement": "^4.0.0",
-        "@rebasepro/data_export": "^4.0.0",
-        "@rebasepro/data_import": "^4.0.0",
-        "@rebasepro/postgresql": "^4.0.0",
-        "@rebasepro/studio": "^4.0.0",
-        "@rebasepro/types": "^4.0.0",
-        "@rebasepro/ui": "^4.0.0",
+        "@rebasepro/auth": "workspace:*",
+        "@rebasepro/core": "workspace:*",
+        "@rebasepro/plugin-data-enhancement": "workspace:*",
+        "@rebasepro/client": "workspace:*",
+        "@rebasepro/cms": "workspace:*",
+        "@rebasepro/studio": "workspace:*",
+        "@rebasepro/types": "workspace:*",
+        "@rebasepro/ui": "workspace:*",
         "@fontsource/jetbrains-mono": "^5.2.5",
-        "{{PROJECT_NAME}}-shared": "workspace:*",
+        "{{PROJECT_NAME}}-shared": "0.0.1",
         "react": "^19.0.0",
         "react-dom": "^19.0.0",
         "react-router": "^7.0.0",