@rebasepro/cli 0.3.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rebasepro/cli",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Developer tools for Rebase projects",
   "main": "./dist/index.cjs",
   "module": "./dist/index.es.js",
@@ -31,10 +31,10 @@
     "execa": "^9.6.1",
     "inquirer": "12.11.1",
     "jiti": "^2.7.0",
-    "@rebasepro/server-core": "0.3.0",
-    "@rebasepro/sdk-generator": "0.3.0",
-    "@rebasepro/server-postgresql": "0.3.0",
-    "@rebasepro/types": "0.3.0"
+    "@rebasepro/sdk-generator": "0.5.0",
+    "@rebasepro/types": "0.5.0",
+    "@rebasepro/server-postgresql": "0.5.0",
+    "@rebasepro/server-core": "0.5.0"
   },
   "devDependencies": {
     "@types/node": "^20.19.41",

package/templates/template/.env.example

@@ -46,6 +46,7 @@ ALLOW_REGISTRATION=true
 # SMTP_USER=
 # SMTP_PASS=
 # SMTP_FROM=noreply@yourapp.com
+# SMTP_NAME=
 # APP_NAME=Your App Name
 
 # ── URLs ──────────────────────────────────────────────────────────────────────

package/templates/template/backend/drizzle.config.ts

@@ -16,15 +16,18 @@ if (!process.env.DATABASE_URL) {
     throw new Error("DATABASE_URL is not set. Make sure .env file exists in the project root and contains DATABASE_URL");
 }
 
-// Extract table names from the generated schema.
-// This ensures drizzle-kit ONLY manages tables defined in the schema.
-// Any tables in the database that are NOT part of the Rebase schema are left untouched.
-const tableNames = Object.values(tables).map(table => getTableName(table as PgTable));
+// Extract table names from the generated schema, excluding system tables in the 'rebase' schema.
+// This ensures drizzle-kit ONLY manages tables defined in the schema, and ignores the system tables
+// managed by Rebase's own bootstrapper.
+const tableNames = Object.values(tables)
+    .filter(table => getTableConfig(table as PgTable).schema !== "rebase")
+    .map(table => getTableName(table as PgTable));
 
-// Dynamically extract all schemas defined in the generated tables to ensure Drizzle Kit manages them.
+// Dynamically extract all schemas defined in the generated tables (excluding 'rebase') to ensure Drizzle Kit manages them.
 const schemas = Array.from(new Set(
     Object.values(tables)
         .map(table => getTableConfig(table as PgTable).schema || "public")
+        .filter(schema => schema !== "rebase")
 ));
 
 export default defineConfig({

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

@@ -1,11 +1,22 @@
 import * as dotenv from "dotenv";
 import path from "path";
 import { fileURLToPath } from "url";
-import { loadEnv } from "@rebasepro/server-core";
+import { loadEnv, z } from "@rebasepro/server-core";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 dotenv.config({ path: path.resolve(__dirname, "../../.env") });
 
-export const env = loadEnv();
+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"),
+    })
+});

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

@@ -13,9 +13,11 @@ import {
     cleanupDevPortFile,
     logger
 } from "@rebasepro/server-core";
+import type { SecurityRule } from "@rebasepro/types";
 import { createPostgresDatabaseConnection, createPostgresAdapter } from "@rebasepro/server-postgresql";
 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);
@@ -25,7 +27,16 @@ const app: Hono<HonoEnv> = new Hono<HonoEnv>();
 
 const isProduction = env.NODE_ENV === "production";
 const allowedOrigins = isProduction
-    ? (env.CORS_ORIGINS || env.FRONTEND_URL || "https://yourdomain.com").split(",").map(s => s.trim())
+    ? (() => {
+        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({
@@ -49,6 +60,13 @@ async function startServer() {
     const PORT = env.PORT;
     const server = createServer(getRequestListener(app.fetch));
 
+    // Default security rules for collections that don't define their own.
+    // Authenticated users can read all rows; only admins can write.
+    const defaultSecurityRules: SecurityRule[] = [
+        { operation: "select", access: "public" },
+        { operations: ["insert", "update", "delete"], roles: ["admin"] }
+    ];
+
     const backend = await initializeRebaseBackend({
         collectionsDir: path.resolve(__dirname, "../../config/collections"),
         functionsDir: path.resolve(__dirname, "../functions"),
@@ -63,6 +81,7 @@ relations },
             connectionString
         }),
         auth: {
+            collection: usersCollection,
             jwtSecret,
             accessExpiresIn: env.JWT_ACCESS_EXPIRES_IN,
             refreshExpiresIn: env.JWT_REFRESH_EXPIRES_IN,
@@ -71,7 +90,23 @@ relations },
                 ? { clientId: env.GOOGLE_CLIENT_ID }
                 : undefined,
             seedDefaultRoles: true,
-            allowRegistration: env.ALLOW_REGISTRATION
+            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,
         },
         storage: env.STORAGE_TYPE === "s3"
             ? {
@@ -87,7 +122,8 @@ relations },
                 type: "local",
                 basePath: env.STORAGE_PATH || path.resolve(__dirname, "../../uploads")
             },
-        history: true
+        history: true,
+        defaultSecurityRules
     });
 
     // ─── Health check ─────────────────────────────────────────────

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

@@ -2,6 +2,5 @@ import postsCollection from "./posts.js";
 import authorsCollection from "./authors.js";
 import tagsCollection from "./tags.js";
 import usersCollection from "./users.js";
-import rolesCollection from "./roles.js";
 
-export const collections = [postsCollection, authorsCollection, tagsCollection, usersCollection, rolesCollection];
+export const collections = [postsCollection, authorsCollection, tagsCollection, usersCollection];

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

@@ -26,7 +26,7 @@ const postsCollection: EntityCollection = {
         content: {
             name: "Content",
             type: "string",
-            multiline: true
+            markdown: true
         },
         status: {
             name: "Status",

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,38 @@
+import { EntityCollection } from "@rebasepro/types";
+
+const categoriesCollection: EntityCollection = {
+    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",
+            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,54 @@
+import { EntityCollection } from "@rebasepro/types";
+
+const ordersCollection: EntityCollection = {
+    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",
+            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,56 @@
+import { EntityCollection } from "@rebasepro/types";
+import categoriesCollection from "./categories.js";
+
+const productsCollection: EntityCollection = {
+    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",
+            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/users.ts

@@ -1,6 +1,5 @@
-import { EntityCollection } from "@rebasepro/types";
-import { resetPasswordAction, deleteEntityAction, RolesFilterSelect, UserRolesSelectField } from "@rebasepro/admin";
-import rolesCollection from "./roles.js";
+import type { EntityCollection } from "@rebasepro/types";
+import { resetPasswordAction, deleteEntityAction } from "@rebasepro/admin";
 
 const usersCollection: EntityCollection = {
     name: "Users",
@@ -12,7 +11,10 @@ const usersCollection: EntityCollection = {
     group: "Settings",
     openEntityMode: "dialog",
     disableDefaultActions: ["copy"],
-    Actions: [RolesFilterSelect],
+    securityRules: [
+        { operation: "select", roles: ["admin"] },
+        { operations: ["insert", "update", "delete"], roles: ["admin"] }
+    ],
     entityActions: [
         resetPasswordAction,
         {
@@ -41,6 +43,7 @@ const usersCollection: EntityCollection = {
         displayName: {
             name: "Name",
             type: "string",
+            columnName: "display_name",
             validation: {
                 required: true
             }
@@ -48,21 +51,21 @@ const usersCollection: EntityCollection = {
         photoURL: {
             name: "Photo URL",
             type: "string",
+            columnName: "photo_url",
             url: "image"
         },
         roles: {
             name: "Roles",
-            type: "relation",
-            target: () => rolesCollection,
-            cardinality: "many",
-            direction: "owning",
-            through: {
-                table: "user_roles",
-                sourceColumn: "user_id",
-                targetColumn: "role_id"
-            },
-            ui: {
-                Field: UserRolesSelectField
+            type: "array",
+            columnType: "text[]",
+            of: {
+                name: "Role",
+                type: "string",
+                enum: {
+                    admin: "Admin",
+                    editor: "Editor",
+                    viewer: "Viewer"
+                }
             }
         },
         passwordHash: {
@@ -114,6 +117,8 @@ const usersCollection: EntityCollection = {
         createdAt: {
             name: "Created At",
             type: "date",
+            columnName: "created_at",
+            autoValue: "on_create",
             ui: {
                 readOnly: true
             }

package/templates/template/docker-compose.yml

@@ -24,7 +24,7 @@ services:
     ports:
       - "5432:5432"
     volumes:
-      - postgres_data:/var/lib/postgresql/data
+      - postgres_data:/var/lib/postgresql
     healthcheck:
       test: ["CMD-SHELL", "pg_isready -U rebase -d rebase"]
       interval: 5s

package/templates/template/package.json

@@ -29,5 +29,11 @@
     },
     "engines": {
         "node": ">=18.0.0"
+    },
+    "pnpm": {
+        "onlyBuiltDependencies": [
+            "esbuild",
+            "sharp"
+        ]
     }
 }

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

@@ -1,62 +0,0 @@
-import { PostgresCollection, EntityCollection } from "@rebasepro/types";
-
-const rolesCollection: PostgresCollection = {
-    name: "Roles",
-    singularName: "Role",
-    slug: "roles",
-    table: "roles",
-    schema: "rebase",
-    icon: "Shield",
-    group: "Settings",
-    properties: {
-        id: {
-            name: "ID",
-            type: "string",
-            isId: "manual",
-            validation: {
-                required: true
-            }
-        },
-        name: {
-            name: "Name",
-            type: "string",
-            validation: {
-                required: true
-            }
-        },
-        isAdmin: {
-            name: "Is Admin",
-            type: "boolean",
-            columnName: "is_admin",
-            defaultValue: false
-        },
-        defaultPermissions: {
-            name: "Default Permissions",
-            type: "map",
-            columnName: "default_permissions",
-            properties: {
-                read: { name: "Read", type: "boolean" },
-                create: { name: "Create", type: "boolean" },
-                edit: { name: "Edit", type: "boolean" },
-                delete: { name: "Delete", type: "boolean" }
-            }
-        },
-        collectionPermissions: {
-            name: "Collection Permissions",
-            type: "map",
-            columnName: "collection_permissions"
-        }
-    }
-};
-
-rolesCollection.securityRules = [
-    {
-        name: "roles_public_access",
-        mode: "permissive",
-        operation: "all",
-        pgRoles: ["public"],
-        using: "true"
-    }
-];
-
-export default rolesCollection;