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

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

@@ -1,134 +1,174 @@
-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 { enums, relations, tables } from "./schema.generated";
-
-import * as dotenv from "dotenv";
+import {
+    initializeRebaseBackend,
+    installShutdownHandlers,
+    serveSPA,
+    HonoEnv,
+    listenWithPortRetry,
+    cleanupDevPortFile,
+    logger
+} from "@rebasepro/server";
+import { createPostgresDatabaseConnection, createPostgresAdapter } from "@rebasepro/server-postgres";
+import { enums, relations, tables } from "./schema.generated.js";
+import { env } from "./env.js";
+import usersCollection from "../../config/collections/users.js";
 
 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: Hono<HonoEnv> = new Hono<HonoEnv>();
+
+const isProduction = env.NODE_ENV === "production";
+const allowedOrigins = isProduction
+    ? (() => {
+        const origins = env.CORS_ORIGINS || env.FRONTEND_URL;
+        if (!origins) {
+            throw new Error(
+                "CORS_ORIGINS or FRONTEND_URL must be set in production. " +
+                "Example: CORS_ORIGINS=https://yourdomain.com"
+            );
+        }
+        return origins.split(",").map(s => s.trim());
+    })()
+    : [];
+
+app.use("/*", cors({
+    origin: (origin) => {
+        if (!isProduction) return origin || "*";
+        return allowedOrigins.includes(origin) ? origin : null;
+    },
+    credentials: true
+}));
 
-const app = express();
-const server = createServer(app);
+app.use("/*", secureHeaders());
 
-// PostgreSQL connection
-const databaseUrl = process.env.DATABASE_URL;
-if (!databaseUrl) {
-    throw new Error("DATABASE_URL environment variable is not set");
-}
-const db = createPostgresDatabaseConnection(databaseUrl);
+// ─── Database ────────────────────────────────────────────────────────
+const databaseUrl = env.DATABASE_URL;
 
-// Middleware
-app.use(cors());
-app.use(express.json({ limit: "10mb" }));
+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)": {
-                connection: db,
-                schema: { tables, enums, relations },
-                adminConnectionString: process.env.ADMIN_CONNECTION_STRING || process.env.DATABASE_URL
-            }
-        },
+        database: createPostgresAdapter({
+            connection: db,
+            schema: { tables,
+enums,
+relations },
+            adminConnectionString: env.ADMIN_CONNECTION_STRING || databaseUrl,
+            connectionString
+        }),
         auth: {
+            collection: usersCollection,
             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,
-            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
+            accessExpiresIn: env.JWT_ACCESS_EXPIRES_IN,
+            refreshExpiresIn: env.JWT_REFRESH_EXPIRES_IN,
+            serviceKey: env.REBASE_SERVICE_KEY,
+            // Cookie-based auth: the refresh token is stored in an httpOnly
+            // cookie (not readable by JS) instead of localStorage, so it is
+            // not exposed to XSS. The frontend opts in via
+            // `authFlowMode: "cookie"` on createRebaseClient. Requires CORS
+            // `credentials: true` (set above).
+            cookieAuth: { sameSite: "Lax" },
+            google: env.GOOGLE_CLIENT_ID
+                ? { clientId: env.GOOGLE_CLIENT_ID }
+                : undefined,
+            allowRegistration: env.ALLOW_REGISTRATION,
+            email: env.SMTP_HOST
+                ? {
+                    from: env.SMTP_FROM || `${env.APP_NAME} <noreply@rebase.pro>`,
+                    smtp: {
+                        host: env.SMTP_HOST,
+                        port: env.SMTP_PORT,
+                        secure: env.SMTP_SECURE,
+                        auth: env.SMTP_USER
+                            ? { user: env.SMTP_USER,
+pass: env.SMTP_PASS! }
+                            : undefined,
+                        name: env.SMTP_NAME
+                    },
+                    appName: env.APP_NAME,
+                    resetPasswordUrl: env.FRONTEND_URL
                 }
-            } : undefined
+                : undefined
         },
-        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, serviceKey: env.REBASE_SERVICE_KEY });
+
+        // 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 ───────────────────────────────────────────────
+    // Drains HTTP, stops crons, tears down realtime, then closes the pool.
+    // Guards against double signals and force-exits if shutdown hangs.
+    installShutdownHandlers(backend, {
+        onCleanup: () => pool.end()
     });
 }
 
 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 { CollectionConfig } from "@rebasepro/types";
+
+const authorsCollection: CollectionConfig = {
+    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,26 @@
+import postsCollection from "./posts.js";
+import authorsCollection from "./authors.js";
+import tagsCollection from "./tags.js";
+import usersCollection from "./users.js";
+import type { SecurityRule } from "@rebasepro/types";
+
+export const collections = [postsCollection, authorsCollection, tagsCollection, usersCollection];
+
+/**
+ * Applied to any collection in this directory that declares no
+ * `securityRules` of its own: anyone can read, only admins can write.
+ *
+ * These live here, next to the collections, because `rebase db push`
+ * generates the Postgres policies from these files — that is what actually
+ * enforces access. A default declared on the server could never reach the
+ * database.
+ *
+ * A collection that declares neither its own rules nor inherits these is
+ * locked by default: admin-only.
+ */
+export const defaultSecurityRules: SecurityRule[] = [
+    { operation: "select",
+access: "public" },
+    { operations: ["insert", "update", "delete"],
+roles: ["admin"] }
+];

package/templates/template/{shared → config}/collections/posts.ts

@@ -1,18 +1,18 @@
-import { EntityCollection } from "@rebasepro/types";
+import { CollectionConfig } from "@rebasepro/types";
+import authorsCollection from "./authors.js";
+import tagsCollection from "./tags.js";
 
-const postsCollection: EntityCollection = {
+const postsCollection: CollectionConfig = {
     name: "Posts",
     singularName: "Post",
     slug: "posts",
-    dbPath: "posts",
+    table: "posts",
     icon: "Article",
     properties: {
         id: {
             name: "ID",
             type: "number",
-            validation: {
-                required: true
-            }
+            isId: "increment"
         },
         title: {
             name: "Title",
@@ -24,7 +24,9 @@ const postsCollection: EntityCollection = {
         content: {
             name: "Content",
             type: "string",
-            multiline: true
+            ui: {
+                markdown: true
+            }
         },
         status: {
             name: "Status",
@@ -33,19 +35,35 @@ const postsCollection: EntityCollection = {
                 {
                     id: "draft",
                     label: "Draft",
-                    color: "grayLight"
+                    color: "gray"
                 },
                 {
                     id: "review",
                     label: "In Review",
-                    color: "orangeLight"
+                    color: "orange"
                 },
                 {
                     id: "published",
                     label: "Published",
-                    color: "greenLight"
+                    color: "green"
                 }
             ]
+        },
+        author: {
+            name: "Author",
+            type: "relation",
+            relationName: "author",
+            target: () => authorsCollection,
+            cardinality: "one",
+            direction: "owning"
+        },
+        tags: {
+            name: "Tags",
+            type: "relation",
+            relationName: "tags",
+            target: () => tagsCollection,
+            cardinality: "many",
+            direction: "owning"
         }
     }
 };

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

@@ -0,0 +1,3 @@
+import usersCollection from "../../users.js";
+
+export const collections = [usersCollection];

package/templates/template/config/collections/presets/ecommerce/categories.ts

@@ -0,0 +1,40 @@
+import { CollectionConfig } from "@rebasepro/types";
+
+const categoriesCollection: CollectionConfig = {
+    name: "Categories",
+    singularName: "Category",
+    slug: "categories",
+    table: "categories",
+    icon: "Category",
+    properties: {
+        id: {
+            name: "ID",
+            type: "number",
+            isId: "increment"
+        },
+        name: {
+            name: "Name",
+            type: "string",
+            validation: { required: true }
+        },
+        slug: {
+            name: "Slug",
+            type: "string",
+            validation: { required: true }
+        },
+        description: {
+            name: "Description",
+            type: "string",
+            ui: {
+                multiline: true
+            }
+        },
+        icon: {
+            name: "Icon",
+            type: "string"
+        }
+    },
+    propertiesOrder: ["id", "name", "slug", "description", "icon"]
+};
+
+export default categoriesCollection;

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

@@ -0,0 +1,6 @@
+import productsCollection from "./products.js";
+import categoriesCollection from "./categories.js";
+import ordersCollection from "./orders.js";
+import usersCollection from "../../users.js";
+
+export const collections = [productsCollection, categoriesCollection, ordersCollection, usersCollection];

package/templates/template/config/collections/presets/ecommerce/orders.ts

@@ -0,0 +1,66 @@
+import { CollectionConfig } from "@rebasepro/types";
+
+const ordersCollection: CollectionConfig = {
+    name: "Orders",
+    singularName: "Order",
+    slug: "orders",
+    table: "orders",
+    icon: "Receipt",
+    properties: {
+        id: {
+            name: "ID",
+            type: "number",
+            isId: "increment"
+        },
+        customerEmail: {
+            name: "Customer Email",
+            type: "string",
+            columnName: "customer_email",
+            validation: { required: true }
+        },
+        status: {
+            name: "Status",
+            type: "string",
+            enum: [
+                { id: "pending",
+label: "Pending",
+color: "gray" },
+                { id: "processing",
+label: "Processing",
+color: "blue" },
+                { id: "shipped",
+label: "Shipped",
+color: "orange" },
+                { id: "delivered",
+label: "Delivered",
+color: "green" },
+                { id: "cancelled",
+label: "Cancelled",
+color: "red" }
+            ]
+        },
+        total: {
+            name: "Total",
+            type: "number",
+            validation: { required: true }
+        },
+        notes: {
+            name: "Notes",
+            type: "string",
+            ui: {
+                multiline: true
+            }
+        },
+        createdAt: {
+            name: "Created At",
+            type: "date",
+            columnName: "created_at",
+            autoValue: "on_create",
+            ui: {
+                readOnly: true
+            }
+        }
+    }
+};
+
+export default ordersCollection;

package/templates/template/config/collections/presets/ecommerce/products.ts

@@ -0,0 +1,64 @@
+import { CollectionConfig } from "@rebasepro/types";
+import categoriesCollection from "./categories.js";
+
+const productsCollection: CollectionConfig = {
+    name: "Products",
+    singularName: "Product",
+    slug: "products",
+    table: "products",
+    icon: "ShoppingCart",
+    properties: {
+        id: {
+            name: "ID",
+            type: "number",
+            isId: "increment"
+        },
+        name: {
+            name: "Name",
+            type: "string",
+            validation: { required: true }
+        },
+        description: {
+            name: "Description",
+            type: "string",
+            ui: {
+                markdown: true
+            }
+        },
+        price: {
+            name: "Price",
+            type: "number",
+            validation: { required: true }
+        },
+        image: {
+            name: "Image",
+            type: "string",
+            storage: { storagePath: "product_images/" }
+        },
+        status: {
+            name: "Status",
+            type: "string",
+            enum: [
+                { id: "draft",
+label: "Draft",
+color: "gray" },
+                { id: "active",
+label: "Active",
+color: "green" },
+                { id: "archived",
+label: "Archived",
+color: "orange" }
+            ]
+        },
+        category: {
+            name: "Category",
+            type: "relation",
+            relationName: "category",
+            target: () => categoriesCollection,
+            cardinality: "one",
+            direction: "owning"
+        }
+    }
+};
+
+export default productsCollection;

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

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