@rebasepro/cli 0.0.1-canary.0 → 0.0.1-canary.000dc36

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

@@ -1,134 +1,148 @@
-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,
+    listenWithPortRetry,
+    cleanupDevPortFile,
+    logger
+} from "@rebasepro/server-core";
+import { createPostgresDatabaseConnection, createPostgresBootstrapper } from "@rebasepro/server-postgresql";
 import { enums, relations, tables } from "./schema.generated";
-
-import * as dotenv from "dotenv";
+import { env } from "./env";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-// Load environment from project root
-dotenv.config({ path: path.resolve(__dirname, "../../.env") });
+// ─── App ─────────────────────────────────────────────────────────────
+const app = new Hono<HonoEnv>();
 
-const app = express();
-const server = createServer(app);
+const isProduction = env.NODE_ENV === "production";
+const allowedOrigins = isProduction
+    ? (env.CORS_ORIGINS || env.FRONTEND_URL || "https://yourdomain.com").split(",").map(s => s.trim())
+    : [];
 
-// PostgreSQL connection
-const databaseUrl = process.env.DATABASE_URL;
-if (!databaseUrl) {
-    throw new Error("DATABASE_URL environment variable is not set");
-}
-const db = createPostgresDatabaseConnection(databaseUrl);
+app.use("/*", cors({
+    origin: (origin) => {
+        if (!isProduction) return origin || "*";
+        return allowedOrigins.includes(origin) ? origin : null;
+    },
+    credentials: true
+}));
 
-// Middleware
-app.use(cors());
-app.use(express.json({ limit: "10mb" }));
+app.use("/*", secureHeaders());
 
+// ─── Database ────────────────────────────────────────────────────────
+const databaseUrl = env.DATABASE_URL;
+
+const { db, pool, 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");
-    }
+    const jwtSecret = env.JWT_SECRET;
+    const PORT = env.PORT;
+    const server = createServer(getRequestListener(app.fetch));
 
-    // Initialize Rebase Backend with auth
     const backend = await initializeRebaseBackend({
-        collectionsDir: path.resolve(__dirname, "../../shared/collections"),
+        collectionsDir: path.resolve(__dirname, "../../config/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
-            }
-        },
+                schema: { tables,
+enums,
+relations },
+                adminConnectionString: 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,
+            accessExpiresIn: env.JWT_ACCESS_EXPIRES_IN,
+            refreshExpiresIn: env.JWT_REFRESH_EXPIRES_IN,
+            serviceKey: env.REBASE_SERVICE_KEY,
+            google: env.GOOGLE_CLIENT_ID
+                ? { clientId: 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: env.ALLOW_REGISTRATION
         },
-        storage: {
-            type: "local",
-            basePath: path.resolve(__dirname, "../../uploads")
-        }
+        storage: env.STORAGE_TYPE === "s3"
+            ? {
+                type: "s3",
+                bucket: env.S3_BUCKET!,
+                region: env.S3_REGION || "auto",
+                accessKeyId: env.S3_ACCESS_KEY_ID || "",
+                secretAccessKey: env.S3_SECRET_ACCESS_KEY || "",
+                endpoint: env.S3_ENDPOINT,
+                forcePathStyle: env.S3_FORCE_PATH_STYLE
+            }
+            : {
+                type: "local",
+                basePath: env.STORAGE_PATH || 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
-        }
+    // ─── Health check ─────────────────────────────────────────────
+    app.get("/health", async (c) => {
+        const result = await backend.healthCheck();
+        const status = result.healthy ? 200 : 503;
+        return c.json({
+            status: result.healthy ? "ok" : "degraded",
+            latencyMs: result.latencyMs,
+            ...(result.details ? { details: result.details } : {})
+        }, status);
     });
 
-    // Serve SPA in production
-    if (process.env.NODE_ENV === "production") {
-        serveSPA(app, {
-            frontendPath: path.join(__dirname, "../../frontend/dist"),
-            excludePaths: ["/health"]
-        });
+    // Serve the frontend in production
+    if (isProduction) {
+        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
+    if (!isProduction) {
+        // Dev mode: retry the next port if the current one is in use
+        const projectRoot = path.resolve(__dirname, "../..");
+        const actualPort = await listenWithPortRetry(server, PORT, { portFileDir: projectRoot });
+
+        // Clean up port file on exit
+        const cleanup = () => cleanupDevPortFile(projectRoot);
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+        process.on("exit", cleanup);
+
+        logger.info(`Server running at http://localhost:${actualPort}`);
+    } else {
+        server.listen(PORT, () => {
+            logger.info(`Server running at http://localhost:${PORT}`);
         });
-    });
-
-    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`);
-    });
+    // ─── Graceful Shutdown ───────────────────────────────────────────────
+    // Uses the framework's built-in shutdown() which drains connections,
+    // stops the cron scheduler, and force-exits after 15s timeout.
+    const gracefulShutdown = async (signal: string) => {
+        logger.info(`Received ${signal}, shutting down...`);
+        await backend.shutdown();
+        await pool.end();
+        logger.info("Database pool closed");
+        process.exit(0);
+    };
+    process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+    process.on("SIGINT", () => gracefulShutdown("SIGINT"));
 }
 
 startServer().catch(err => {
-    console.error("Failed to start server:", err);
+    logger.error("Failed to start server", { error: err instanceof Error ? err : new Error(String(err)) });
     process.exit(1);
 });
 
-export { app, server };
+export { app };

package/templates/template/backend/tsconfig.json

@@ -15,5 +15,5 @@
     "sourceMap": true,
     "jsx": "preserve"
   },
-  "include": ["src/**/*", "../shared/**/*", "drizzle.config.ts"]
+  "include": ["src/**/*", "../config/**/*", "drizzle.config.ts"]
 }

package/templates/template/config/collections/authors.ts

@@ -0,0 +1,45 @@
+import { EntityCollection } from "@rebasepro/types";
+
+const authorsCollection: EntityCollection = {
+    name: "Authors",
+    singularName: "Author",
+    slug: "authors",
+    table: "authors",
+    icon: "Person",
+    properties: {
+        id: {
+            name: "ID",
+            type: "number",
+            isId: "increment"
+        },
+        name: {
+            name: "Name",
+            type: "string",
+            validation: {
+                required: true
+            }
+        },
+        email: {
+            name: "Email",
+            type: "string",
+            validation: {
+                required: true
+            }
+        },
+        picture: {
+            name: "Picture",
+            type: "string",
+            storage: {
+                storagePath: "author_pictures/"
+            }
+        }
+    },
+    propertiesOrder: [
+        "id",
+        "name",
+        "email",
+        "picture"
+    ]
+};
+
+export default authorsCollection;

package/templates/template/config/collections/index.ts

@@ -0,0 +1,5 @@
+import postsCollection from "./posts";
+import authorsCollection from "./authors";
+import tagsCollection from "./tags";
+
+export const collections = [postsCollection, authorsCollection, tagsCollection];

package/templates/template/config/collections/posts.ts

@@ -0,0 +1,91 @@
+import { EntityCollection } from "@rebasepro/types";
+import authorsCollection from "./authors";
+import tagsCollection from "./tags";
+
+const postsCollection: EntityCollection = {
+    name: "Posts",
+    singularName: "Post",
+    slug: "posts",
+    table: "posts",
+    icon: "Article",
+    properties: {
+        id: {
+            name: "ID",
+            type: "number",
+            validation: {
+                required: true
+            }
+        },
+        title: {
+            name: "Title",
+            type: "string",
+            validation: {
+                required: true
+            }
+        },
+        content: {
+            name: "Content",
+            type: "string",
+            multiline: true
+        },
+        status: {
+            name: "Status",
+            type: "string",
+            enum: [
+                {
+                    id: "draft",
+                    label: "Draft",
+                    color: "gray"
+                },
+                {
+                    id: "review",
+                    label: "In Review",
+                    color: "orange"
+                },
+                {
+                    id: "published",
+                    label: "Published",
+                    color: "green"
+                }
+            ]
+        },
+        author: {
+            name: "Author",
+            type: "relation",
+            relationName: "author",
+            relation: {
+                relationName: "author",
+                cardinality: "one",
+                direction: "owning",
+                target: () => authorsCollection
+            }
+        },
+        tags: {
+            name: "Tags",
+            type: "relation",
+            relationName: "tags",
+            relation: {
+                relationName: "tags",
+                cardinality: "many",
+                direction: "owning",
+                target: () => tagsCollection
+            }
+        }
+    },
+    relations: [
+        {
+            relationName: "author",
+            target: () => authorsCollection,
+            cardinality: "one",
+            direction: "owning"
+        },
+        {
+            relationName: "tags",
+            target: () => tagsCollection,
+            cardinality: "many",
+            direction: "owning"
+        }
+    ]
+};
+
+export default postsCollection;

package/templates/template/config/collections/tags.ts

@@ -0,0 +1,27 @@
+import { EntityCollection } from "@rebasepro/types";
+
+const tagsCollection: EntityCollection = {
+    name: "Tags",
+    singularName: "Tag",
+    slug: "tags",
+    table: "tags",
+    icon: "Tag",
+    properties: {
+        id: {
+            name: "ID",
+            type: "number",
+            validation: {
+                required: true
+            }
+        },
+        name: {
+            name: "Tag Name",
+            type: "string",
+            validation: {
+                required: true
+            }
+        }
+    }
+};
+
+export default tagsCollection;

package/templates/template/config/package.json

@@ -0,0 +1,28 @@
+{
+    "name": "{{PROJECT_NAME}}-config",
+    "version": "1.0.0",
+    "description": "Shared collections for frontend and backend",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "type": "module",
+    "private": true,
+    "scripts": {
+        "build": "tsc",
+        "dev": "tsc --watch",
+        "clean": "rm -rf dist"
+    },
+    "dependencies": {
+        "@rebasepro/types": "workspace:*"
+    },
+    "devDependencies": {
+        "typescript": "^5.9.2"
+    },
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
+        },
+        "./package.json": "./package.json"
+    }
+}

package/templates/template/docker-compose.yml

@@ -1,48 +1,84 @@
-version: '3.8'
+# ─── Rebase — Production Docker Compose ──────────────────────────────
+#
+# Quick start:
+#   cp .env.example .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:15-alpine
+    image: postgres:18-alpine
+    restart: unless-stopped
     environment:
       POSTGRES_USER: rebase
-      POSTGRES_PASSWORD: rebasepassword
+      POSTGRES_PASSWORD: ${DATABASE_PASSWORD:-changeme}
       POSTGRES_DB: rebase
     ports:
       - "5432:5432"
     volumes:
       - postgres_data:/var/lib/postgresql/data
     healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U rebase"]
+      test: ["CMD-SHELL", "pg_isready -U rebase -d 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"
+    env_file: .env
     environment:
-      - DATABASE_URL=postgresql://rebase:rebasepassword@db:5432/rebase
-      - JWT_SECRET=super-secret-jwt-key
-      - NODE_ENV=development
+      # Override DATABASE_URL to point to the Docker network service
+      DATABASE_URL: postgresql://rebase:${DATABASE_PASSWORD:-changeme}@db:5432/rebase
+      ADMIN_CONNECTION_STRING: postgresql://rebase:${DATABASE_PASSWORD:-changeme}@db:5432/rebase
+      NODE_ENV: production
+      PORT: "3001"
     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
+      - "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
+COPY config ./config
 
 # Install dependencies
-RUN pnpm install
+RUN pnpm install --frozen-lockfile
+
+# Build config first, then frontend
+RUN pnpm --filter "*-config" 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;
+}