@rebasepro/cli 0.0.1-canary.1 → 0.0.1-canary.3263433

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/admin": "workspace:*",
+        "@rebasepro/studio": "workspace:*",
+        "@rebasepro/types": "workspace:*",
+        "@rebasepro/ui": "workspace:*",
         "@fontsource/jetbrains-mono": "^5.2.5",
-        "{{PROJECT_NAME}}-shared": "workspace:*",
+        "{{PROJECT_NAME}}-config": "workspace:*",
         "react": "^19.0.0",
         "react-dom": "^19.0.0",
         "react-router": "^7.0.0",

package/templates/template/frontend/src/App.tsx

@@ -1,132 +1,46 @@
-import React, { useCallback } from "react";
+import React from "react";
 
 import "@fontsource/jetbrains-mono";
 import "typeface-rubik";
 
-import {
-    RebaseLoginView,
-    useBackendUserManagement,
-    useRebaseAuthController
-} from "@rebasepro/auth";
-import {
-    AppBar,
-    CircularProgressCenter,
-    Drawer,
-    Rebase,
-    RebaseRoute,
-    ModeControllerProvider,
-    NotFoundPage,
-    Scaffold,
-    SideDialogs,
-    RebaseRoutes,
-    SnackbarProvider,
-    ContentHomePage,
-    useBackendStorageSource,
-    useBuildCMSUrlController,
-    useBuildCollectionRegistryController,
-    useBuildLocalConfigurationPersistence,
-    useBuildModeController,
-    useBuildNavigationStateController
-} from "@rebasepro/core";
-import { usePostgresClientDataSource } from "@rebasepro/postgresql";
+import { useRebaseAuthController, useBackendUserManagement, RebaseAuth } from "@rebasepro/auth";
+import { Rebase } from "@rebasepro/core";
+import { RebaseCMS, RebaseShell } from "@rebasepro/admin";
+import { RebaseStudio } from "@rebasepro/studio";
+import { createRebaseClient } from "@rebasepro/client";
 import { collections } from "virtual:rebase-collections";
-import { Route, Outlet } from "react-router-dom";
 
 // Configuration from environment
-const API_URL = import.meta.env.VITE_API_URL || "http://localhost:3001";
+const API_URL = import.meta.env.VITE_API_URL || (import.meta.env.DEV ? "http://localhost:3001" : undefined);
 const GOOGLE_CLIENT_ID = import.meta.env.VITE_GOOGLE_CLIENT_ID;
 
 export function App() {
-    const modeController = useBuildModeController();
-    const userConfigPersistence = useBuildLocalConfigurationPersistence();
+    const rebaseClient = React.useMemo(() => createRebaseClient({
+        baseUrl: API_URL
+    }), []);
 
     const authController = useRebaseAuthController({
-        apiUrl: API_URL,
+        client: rebaseClient,
         googleClientId: GOOGLE_CLIENT_ID
     });
 
-    const storageSource = useBackendStorageSource({
-        apiUrl: API_URL,
-        getAuthToken: authController.getAuthToken
-    });
-
     const userManagement = useBackendUserManagement({
-        apiUrl: API_URL,
-        getAuthToken: authController.getAuthToken,
+        client: rebaseClient,
         currentUser: authController.user
     });
 
-    const postgresDelegate = usePostgresClientDataSource({
-        websocketUrl: API_URL.replace(/^http/, "ws"),
-        getAuthToken: authController.initialLoading ? undefined : authController.getAuthToken
-    });
-
-    const collectionsBuilder = useCallback(() => {
-        return [...collections];
-    }, []);
-
-    const collectionRegistryController = useBuildCollectionRegistryController({ userConfigPersistence });
-    const cmsUrlController = useBuildCMSUrlController({
-        basePath: "/",
-        baseCollectionPath: "/c",
-        collectionRegistryController
-    });
-
-    const navigationStateController = useBuildNavigationStateController({
-        collections: collectionsBuilder,
-        authController,
-        dataSource: postgresDelegate,
-        collectionRegistryController,
-        cmsUrlController,
-        userManagement
-    });
-
     return (
-        <SnackbarProvider>
-            <ModeControllerProvider value={modeController}>
-                <Rebase
-                    collectionRegistryController={collectionRegistryController}
-                    cmsUrlController={cmsUrlController}
-                    navigationStateController={navigationStateController}
-                    authController={authController}
-                    userConfigPersistence={userConfigPersistence}
-                    dataSource={postgresDelegate}
-                    storageSource={storageSource}
-                >
-                    {({ loading }) => {
-                        if (loading || authController.initialLoading) {
-                            return <CircularProgressCenter />;
-                        }
-
-                        if (!authController.user) {
-                            return (
-                                <RebaseLoginView
-                                    authController={authController}
-                                    googleEnabled={!!GOOGLE_CLIENT_ID}
-                                    googleClientId={GOOGLE_CLIENT_ID}
-                                />
-                            );
-                        }
-
-                        return (
-                            <RebaseRoutes>
-                                <Route element={
-                                    <Scaffold autoOpenDrawer={false}>
-                                        <AppBar />
-                                        <Drawer />
-                                        <Outlet />
-                                        <SideDialogs />
-                                    </Scaffold>
-                                }>
-                                    <Route path={"/"} element={<ContentHomePage />} />
-                                    <Route path={"/c/*"} element={<RebaseRoute />} />
-                                    <Route path={"*"} element={<NotFoundPage />} />
-                                </Route>
-                            </RebaseRoutes>
-                        );
-                    }}
-                </Rebase>
-            </ModeControllerProvider>
-        </SnackbarProvider>
+        <Rebase
+            client={rebaseClient}
+            authController={authController}
+            userManagement={userManagement}
+        >
+            <RebaseAuth />
+            <RebaseCMS
+                collections={collections}
+            />
+            <RebaseStudio/>
+            <RebaseShell title="Rebase"/>
+        </Rebase>
     );
 }

package/templates/template/frontend/src/index.css

@@ -1,2 +1,16 @@
 @import "tailwindcss";
-@import "@rebasepro/ui/index.css";
+@import "@rebasepro/ui/index.css" layer(base);
+
+@source "../node_modules/@rebasepro";
+
+@custom-variant dark (&:where(.dark, .dark *));
+
+@layer utilities {
+    body {
+        @apply w-full min-h-screen bg-surface-50 dark:bg-surface-900 flex flex-col items-center justify-center;
+    }
+
+    a {
+        @apply text-primary dark:text-primary;
+    }
+}

package/templates/template/frontend/src/main.tsx

@@ -7,12 +7,12 @@ import "./index.css";
 const router = createBrowserRouter([
     {
         path: "/*",
-        element: <App />
+        element: <App/>
     }
 ]);
 
 ReactDOM.createRoot(document.getElementById("root") as HTMLElement).render(
     <React.StrictMode>
-        <RouterProvider router={router} />
+        <RouterProvider router={router}/>
     </React.StrictMode>
 );

package/templates/template/frontend/vite.config.ts

@@ -7,20 +7,50 @@ import tailwindcss from "@tailwindcss/vite";
 import { rebaseCollectionsPlugin } from "@rebasepro/core/vitePlugin";
 
 export default defineConfig({
+    envDir: path.resolve(__dirname, ".."),
     esbuild: {
         logOverride: { "this-is-undefined-in-esm": "silent" }
     },
     build: {
         minify: true,
-        outDir: "./build",
+        outDir: "./dist",
         target: "ESNEXT",
-        sourcemap: true
+        sourcemap: true,
+        rollupOptions: {
+            output: {
+                manualChunks(id) {
+                    // Heavy vendor libraries — split into individually cached chunks
+                    if (id.includes("xlsx")) return "vendor-xlsx";
+                    if (id.includes("prosemirror")) return "vendor-prosemirror";
+                    if (id.includes("monaco-editor") || id.includes("@monaco-editor")) return "vendor-monaco";
+                    if (id.includes("@xyflow") || id.includes("dagre")) return "vendor-xyflow";
+                    if (id.includes("@dnd-kit")) return "vendor-dnd";
+                    if (id.includes("prism-react-renderer")) return "vendor-prism";
+                    if (id.includes("markdown-it")) return "vendor-markdown";
+                    if (id.includes("react-dropzone")) return "vendor-dropzone";
+                    if (id.includes("date-fns")) return "vendor-datefns";
+                    if (id.includes("fuse.js")) return "vendor-fuse";
+                    if (id.includes("node_modules/react-dom/")) return "vendor-react-dom";
+                    if (id.includes("node_modules/react-router") || id.includes("node_modules/@remix-run")) return "vendor-react-router";
+                    if (id.includes("node_modules/@radix-ui/")) return "vendor-radix";
+                    if (id.includes("node_modules/framer-motion/")) return "vendor-framer-motion";
+                    if (id.includes("node_modules/zod/")) return "vendor-zod";
+                    if (id.includes("node_modules/i18next") || id.includes("node_modules/react-i18next")) return "vendor-i18next";
+                    if (id.includes("node_modules/@floating-ui/")) return "vendor-floating-ui";
+                    if (id.includes("node_modules/tailwind-merge/")) return "vendor-tailwind-merge";
+                    if (id.includes("node_modules/notistack/")) return "vendor-notistack";
+                    if (id.includes("node_modules/lucide-react/")) return "vendor-lucide-react";
+
+                    return undefined;
+                }
+            }
+        }
     },
     optimizeDeps: { include: ["react/jsx-runtime"] },
     plugins: [
         svgr(),
         react({}),
         tailwindcss(),
-        rebaseCollectionsPlugin({ collectionsDir: "../shared/collections" })
+        rebaseCollectionsPlugin({ collectionsDir: "../config/collections" })
     ]
 });

package/templates/template/package.json

@@ -4,25 +4,21 @@
     "description": "Rebase application with PostgreSQL backend",
     "private": true,
     "type": "module",
-    "workspaces": [
-        "frontend",
-        "backend",
-        "shared"
-    ],
     "scripts": {
-        "dev": "concurrently \"pnpm run dev:backend\" \"pnpm run dev:frontend\"",
-        "dev:frontend": "cd frontend && pnpm run dev",
-        "dev:backend": "cd backend && pnpm run dev",
-        "build": "pnpm run build:shared && pnpm run build:frontend && pnpm run build:backend",
-        "build:shared": "cd shared && pnpm run build",
-        "build:frontend": "cd frontend && pnpm run build",
-        "build:backend": "cd backend && pnpm run build",
-        "start": "cd backend && pnpm start",
-        "db:generate": "cd backend && pnpm run db:generate",
-        "db:migrate": "cd backend && pnpm run db:migrate",
-        "db:studio": "cd backend && pnpm run db:studio"
+        "dev": "rebase dev",
+        "build": "pnpm -r run build",
+        "start": "pnpm --filter \"*-backend\" start",
+        "db:generate": "rebase db generate --collections ../config/collections",
+        "db:migrate": "rebase db migrate",
+        "db:pull": "rebase db pull",
+        "db:push": "rebase db push --collections ../config/collections",
+        "db:studio": "rebase db studio",
+        "schema:generate": "rebase schema generate --collections ../config/collections",
+        "generate:sdk": "rebase generate-sdk",
+        "deploy": "pnpm run build && pnpm run start"
     },
     "devDependencies": {
+        "@rebasepro/cli": "workspace:*",
         "concurrently": "^8.2.2",
         "typescript": "^5.9.2"
     },

package/templates/template/pnpm-workspace.yaml

@@ -0,0 +1,4 @@
+packages:
+  - "frontend"
+  - "backend"
+  - "config"

package/templates/template/scripts/example.ts

@@ -0,0 +1,91 @@
+/**
+ * Example Rebase Script
+ *
+ * Scripts run OUTSIDE the server and need explicit authentication.
+ * Use a Service Key (set in .env as REBASE_SERVICE_KEY) to get admin
+ * access — similar to a Firebase Service Account credential.
+ *
+ * Usage:
+ *   # With local dev server running (`pnpm dev` in another terminal):
+ *   npx tsx scripts/example.ts
+ *
+ *   # With remote backend:
+ *   REBASE_URL=https://api.yourdomain.com npx tsx scripts/example.ts
+ *
+ *   # Service key can also be passed as env var:
+ *   REBASE_SERVICE_KEY=<key> REBASE_URL=https://api.yourdomain.com npx tsx scripts/example.ts
+ *
+ * Generate a service key:
+ *   node -e "console.log(require('crypto').randomBytes(48).toString('base64'))"
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import * as dotenv from "dotenv";
+import { createRebaseClient } from "@rebasepro/client";
+// import type { Database } from "../config/database.types"; // Optional: For fully typed collections
+
+// Load .env from project root (same file the backend uses)
+dotenv.config({ path: path.resolve(process.cwd(), ".env") });
+
+// ─── Resolve Backend URL ─────────────────────────────────────────────
+let baseUrl = process.env.REBASE_URL;
+
+if (!baseUrl) {
+    try {
+        // Try to read the URL from the local dev server
+        const urlFile = path.join(process.cwd(), ".rebase-dev-url");
+        if (fs.existsSync(urlFile)) {
+            baseUrl = fs.readFileSync(urlFile, "utf-8").trim();
+            console.log(`Found local dev server running at: ${baseUrl}`);
+        }
+    } catch (e) {
+        // Ignore errors reading the file
+    }
+}
+
+if (!baseUrl) {
+    console.error("❌ No backend URL found!");
+    console.error("");
+    console.error("Please make sure you have either:");
+    console.error("1. Started the local dev server in another terminal (`pnpm dev`)");
+    console.error("2. Set the REBASE_URL environment variable (e.g. `REBASE_URL=https://api.yourdomain.com npx tsx scripts/example.ts`)");
+    process.exit(1);
+}
+
+// ─── Resolve Service Key ─────────────────────────────────────────────
+const serviceKey = process.env.REBASE_SERVICE_KEY;
+
+if (!serviceKey) {
+    console.warn("⚠️  No REBASE_SERVICE_KEY found — requests will be unauthenticated.");
+    console.warn("   Set REBASE_SERVICE_KEY in your .env to get admin access.");
+    console.warn("   Generate one with: node -e \"console.log(require('crypto').randomBytes(48).toString('base64'))\"");
+    console.warn("");
+}
+
+// ─── Initialize the SDK client ───────────────────────────────────────
+const rebase = createRebaseClient({
+    baseUrl,
+    // The service key is sent as a Bearer token for admin access
+    token: serviceKey
+});
+
+async function run() {
+    console.log("🚀 Starting script...");
+
+    try {
+        // Example: Check backend health
+        const health = await fetch(`${baseUrl}/api/health`).then(res => res.json());
+        console.log("✅ Backend health:", health);
+
+        // Example: Fetch some data (requires auth if backend is secure-by-default)
+        // const items = await rebase.data.collection("users").find({ limit: 5 });
+        // console.log("Items:", items);
+
+        console.log("✨ Script finished successfully.");
+    } catch (error) {
+        console.error("❌ Script failed:", error);
+    }
+}
+
+run();

package/templates/template/.env.template

@@ -1,31 +0,0 @@
-# Database Configuration
-DATABASE_URL=postgresql://postgres:password@localhost:5432/rebase
-
-# Server Configuration
-PORT=3001
-NODE_ENV=development
-
-# JWT Authentication
-JWT_SECRET=change-this-to-a-secure-random-string
-JWT_ACCESS_EXPIRES_IN=1h
-JWT_REFRESH_EXPIRES_IN=30d
-
-# Allow new user registration
-ALLOW_REGISTRATION=true
-
-# Frontend API URL
-VITE_API_URL=http://localhost:3001
-
-# Google OAuth (optional — uncomment to enable)
-# GOOGLE_CLIENT_ID=your-google-client-id
-# VITE_GOOGLE_CLIENT_ID=your-google-client-id
-
-# Email (optional — uncomment to enable password reset emails)
-# SMTP_HOST=smtp.example.com
-# SMTP_PORT=587
-# SMTP_SECURE=false
-# SMTP_USER=your-smtp-username
-# SMTP_PASS=your-smtp-password
-# SMTP_FROM=noreply@yourapp.com
-# APP_NAME=My Rebase App
-# FRONTEND_URL=http://localhost:5173

package/templates/template/backend/scripts/db-generate.ts

@@ -1,60 +0,0 @@
-#!/usr/bin/env node
-import { spawn } from "child_process";
-
-// --- Helper Functions ---
-const formatTerminalText = (text: string, options: {
-    bold?: boolean;
-    backgroundColor?: "blue" | "green" | "red" | "yellow" | "cyan" | "magenta";
-    textColor?: "white" | "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan";
-} = {}): string => {
-    let codes = "";
-    if (options.bold) codes += "\x1b[1m";
-    if (options.backgroundColor) {
-        const bgColors = {
-            blue: "\x1b[44m",
-            green: "\x1b[42m",
-            red: "\x1b[41m",
-            yellow: "\x1b[43m",
-            cyan: "\x1b[46m",
-            magenta: "\x1b[45m"
-        } as const;
-        codes += bgColors[options.backgroundColor];
-    }
-    if (options.textColor) {
-        const textColors = {
-            white: "\x1b[37m",
-            black: "\x1b[30m",
-            red: "\x1b[31m",
-            green: "\x1b[32m",
-            yellow: "\x1b[33m",
-            blue: "\x1b[34m",
-            magenta: "\x1b[35m",
-            cyan: "\x1b[36m"
-        } as const;
-        codes += textColors[options.textColor];
-    }
-    return `${codes}${text}\x1b[0m`;
-};
-
-// Run drizzle-kit generate with the correct env path
-const child = spawn("npx", ["drizzle-kit", "generate"], {
-    stdio: "inherit",
-    env: {
-        ...process.env,
-        DOTENV_CONFIG_PATH: "../.env"
-    },
-    shell: true
-});
-
-child.on("close", (code) => {
-    if (code === 0) {
-        console.log("");
-        console.log(`You can now run ${formatTerminalText("pnpm db:migrate", {
-            bold: true,
-            backgroundColor: "green",
-            textColor: "black"
-        })} to apply the migrations to your database.`);
-        console.log("");
-    }
-    process.exit(code ?? 0);
-});

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

@@ -1,3 +0,0 @@
-import postsCollection from "./posts";
-
-export const collections = [postsCollection];

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

@@ -1,53 +0,0 @@
-import { EntityCollection } from "@rebasepro/types";
-
-const postsCollection: EntityCollection = {
-    name: "Posts",
-    singularName: "Post",
-    slug: "posts",
-    dbPath: "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: "grayLight"
-                },
-                {
-                    id: "review",
-                    label: "In Review",
-                    color: "orangeLight"
-                },
-                {
-                    id: "published",
-                    label: "Published",
-                    color: "greenLight"
-                }
-            ]
-        }
-    }
-};
-
-export default postsCollection;

package/templates/template/shared/package.json

@@ -1,28 +0,0 @@
-{
-  "name": "{{PROJECT_NAME}}-shared",
-  "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": "^4.0.0"
-  },
-  "devDependencies": {
-    "typescript": "^5.9.2"
-  },
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    },
-    "./package.json": "./package.json"
-  }
-}