@rebasepro/cli 0.1.0 → 0.2.1

package/dist/index.es.js

@@ -4,8 +4,8 @@ import inquirer from "inquirer";
 import path from "path";
 import fs from "fs";
 import { promisify } from "util";
-import execa from "execa";
-import ncp from "ncp";
+import { execa, execaCommandSync } from "execa";
+import { cp } from "fs/promises";
 import { fileURLToPath } from "url";
 import crypto from "crypto";
 import { generateSDK } from "@rebasepro/sdk-generator";
@@ -51,7 +51,6 @@ function getPMCommands(pm) {
   };
 }
 const access = promisify(fs.access);
-const copy = promisify(ncp);
 const __filename$2 = fileURLToPath(import.meta.url);
 const __dirname$2 = path.dirname(__filename$2);
 function findParentDir(currentDir, targetName) {
@@ -78,8 +77,12 @@ async function promptForOptions(rawArgs, pm) {
     {
       "--git": Boolean,
       "--install": Boolean,
+      "--database-url": String,
+      "--introspect": Boolean,
+      "--yes": Boolean,
       "-g": "--git",
-      "-i": "--install"
+      "-i": "--install",
+      "-y": "--yes"
     },
     {
       argv: rawArgs.slice(3),
@@ -88,6 +91,24 @@ async function promptForOptions(rawArgs, pm) {
     }
   );
   const nameArg = args._[0];
+  const isNonInteractive = args["--yes"] || false;
+  if (isNonInteractive) {
+    const projectName2 = nameArg || "my-rebase-app";
+    const targetDirectory2 = path.resolve(process.cwd(), projectName2);
+    const templateDirectory2 = path.resolve(cliRoot, "templates", "template");
+    const pmCommands2 = getPMCommands(pm);
+    return {
+      projectName: path.basename(targetDirectory2),
+      git: args["--git"] ?? false,
+      installDeps: args["--install"] ?? false,
+      targetDirectory: targetDirectory2,
+      templateDirectory: templateDirectory2,
+      databaseUrl: args["--database-url"] || void 0,
+      introspect: args["--introspect"] || false,
+      pm,
+      pmCommands: pmCommands2
+    };
+  }
   const questions = [];
   if (!nameArg) {
     questions.push({
@@ -167,9 +188,8 @@ async function createProject(options) {
   }
   console.log(chalk.gray("  Copying project files..."));
   try {
-    await copy(options.templateDirectory, options.targetDirectory, {
-      clobber: false,
-      dot: true,
+    await cp(options.templateDirectory, options.targetDirectory, {
+      recursive: true,
       filter: (source) => {
         const basename = path.basename(source);
         return basename !== "node_modules" && basename !== ".DS_Store";
@@ -273,6 +293,10 @@ async function replacePlaceholders(options) {
   const viewBin = "npm";
   const getPackageVersion = async (pkgName) => {
     if (versionCache.has(pkgName)) return versionCache.get(pkgName);
+    if (process.env.REBASE_E2E === "true") {
+      versionCache.set(pkgName, cliVersion);
+      return cliVersion;
+    }
     let versionToUse = cliVersion;
     try {
       const { stdout } = await execa(viewBin, ["view", `${pkgName}@${cliVersion}`, "version"]);
@@ -440,6 +464,7 @@ async function generateSdkCommand(args) {
   console.log("");
   console.log(chalk.cyan("  → Loading collection definitions..."));
   const collections = await loadCollections(resolvedCollectionsDir);
+  collections.sort((a, b) => a.slug.localeCompare(b.slug));
   if (collections.length === 0) {
     console.log(chalk.red("  ✗ No collections found. Nothing to generate."));
     process.exit(1);
@@ -499,15 +524,20 @@ function getActiveBackendPlugin(backendDir) {
   if (!fs.existsSync(pkgPath)) return null;
   try {
     const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-    const deps = {
-      ...pkg.dependencies,
-      ...pkg.devDependencies
-    };
-    for (const dep of Object.keys(deps)) {
-      if (dep.startsWith("@rebasepro/server-") && dep !== "@rebasepro/server-core") {
-        return dep;
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const candidates = Object.keys(deps).filter(
+      (dep) => dep.startsWith("@rebasepro/server-") && dep !== "@rebasepro/server-core"
+    );
+    if (candidates.length === 0) return null;
+    if (candidates.includes("@rebasepro/server-postgresql")) {
+      return "@rebasepro/server-postgresql";
+    }
+    for (const candidate of candidates) {
+      if (resolvePluginCliScript(backendDir, candidate)) {
+        return candidate;
       }
     }
+    return candidates[0];
   } catch {
   }
   return null;
@@ -569,7 +599,7 @@ function requireProjectRoot() {
   if (!root) {
     console.error(chalk.red("✗ Could not find a Rebase project root."));
     console.error(chalk.gray("  Make sure you are inside a Rebase project directory"));
-    console.error(chalk.gray("  (one with backend/, frontend/, and shared/ directories)."));
+    console.error(chalk.gray("  (one with backend/, frontend/, and config/ directories)."));
     process.exit(1);
   }
   return root;
@@ -752,10 +782,12 @@ async function devCommand(rawArgs) {
       "--backend-only": Boolean,
       "--frontend-only": Boolean,
       "--port": Number,
+      "--generate": Boolean,
       "--help": Boolean,
       "-b": "--backend-only",
       "-f": "--frontend-only",
       "-p": "--port",
+      "-g": "--generate",
       "-h": "--help"
     },
     {
@@ -773,6 +805,7 @@ async function devCommand(rawArgs) {
   const frontendDir = findFrontendDir(projectRoot);
   const backendOnly = args["--backend-only"] || false;
   const frontendOnly = args["--frontend-only"] || false;
+  const shouldGenerate = args["--generate"] || process.env.REBASE_AUTO_GENERATE === "true" || process.env.REBASE_GENERATE === "true";
   const startPort = resolveStartPort(projectRoot, args["--port"]);
   console.log("");
   console.log(chalk.bold("  🚀 Rebase Dev Server"));
@@ -792,10 +825,10 @@ async function devCommand(rawArgs) {
       console.log("");
       console.log(chalk.cyan("┌────────────────────────────────────────────────────────────┐"));
       console.log(chalk.cyan("│                                                            │"));
-      console.log(chalk.cyan("│   ✨ Rebase Admin App is ready!                            │"));
+      console.log(chalk.cyan("│   ✦ Rebase Admin App is ready!                             │"));
       const cleanUrl = stripAnsi(frontendUrl);
-      const paddedUrl = cleanUrl.padEnd(40);
-      console.log(chalk.cyan("│   👉 Frontend URL: ") + chalk.white(paddedUrl) + chalk.cyan("│"));
+      const paddedUrl = cleanUrl.padEnd(41);
+      console.log(chalk.cyan("│   ➜ Frontend URL: ") + chalk.white(paddedUrl) + chalk.cyan("│"));
       console.log(chalk.cyan("│                                                            │"));
       console.log(chalk.cyan("└────────────────────────────────────────────────────────────┘"));
       console.log("");
@@ -814,7 +847,7 @@ async function devCommand(rawArgs) {
       if (child.pid && !child.killed) {
         try {
           if (process.platform === "win32") {
-            execa.commandSync(`taskkill /pid ${child.pid} /T /F`);
+            execaCommandSync(`taskkill /pid ${child.pid} /T /F`);
           } else {
             process.kill(-child.pid, "SIGKILL");
           }
@@ -892,9 +925,67 @@ async function devCommand(rawArgs) {
     console.log(`  ${chalk.cyan("▶")} Backend:  ${chalk.gray(backendDir)}`);
     console.log(`  ${chalk.gray("↳ PORT")} = ${chalk.white(String(startPort))}`);
     let frontendLaunched = false;
+    if (shouldGenerate) {
+      console.log(chalk.gray("  → Ensuring schema and SDK are generated on start..."));
+      try {
+        const activePlugin = getActiveBackendPlugin(backendDir);
+        const pluginCli = activePlugin ? resolvePluginCliScript(backendDir, activePlugin) : null;
+        if (pluginCli) {
+          await execa(tsxBin, [pluginCli, "schema", "generate"], {
+            cwd: backendDir,
+            stdio: "inherit",
+            env
+          });
+        }
+        await execa("npx", ["rebase", "generate-sdk"], {
+          cwd: projectRoot,
+          stdio: "inherit",
+          env
+        });
+        console.log(chalk.green("  ✓ Initial schema and SDK generated successfully.\n"));
+      } catch (err) {
+        console.error(chalk.red(`  ✗ Initial schema/SDK generation failed: ${err.message || err}
+`));
+      }
+      const collectionsDir = path.join(projectRoot, "config", "collections");
+      if (fs.existsSync(collectionsDir)) {
+        let watchDebounce = null;
+        fs.watch(collectionsDir, { recursive: true }, (eventType, filename) => {
+          if (!filename || filename.startsWith(".") || filename.endsWith(".tmp")) return;
+          if (watchDebounce) clearTimeout(watchDebounce);
+          watchDebounce = setTimeout(async () => {
+            console.log(chalk.yellow(`
+  🔄 Collection change detected (${filename}). Regenerating schema & SDK...`));
+            try {
+              const activePlugin = getActiveBackendPlugin(backendDir);
+              const pluginCli = activePlugin ? resolvePluginCliScript(backendDir, activePlugin) : null;
+              if (pluginCli) {
+                await execa(tsxBin, [pluginCli, "schema", "generate"], {
+                  cwd: backendDir,
+                  stdio: "inherit",
+                  env
+                });
+              }
+              await execa("npx", ["rebase", "generate-sdk"], {
+                cwd: projectRoot,
+                stdio: "inherit",
+                env
+              });
+              console.log(chalk.green("  ✓ Schema & SDK regenerated successfully. Hono will reload."));
+            } catch (err) {
+              console.error(chalk.red(`  ✗ Failed to regenerate schema/SDK: ${err.message || err}`));
+            }
+          }, 300);
+        });
+      }
+    }
+    const watchArgs = ["watch", "--conditions", "development", "src/index.ts"];
+    if (!shouldGenerate) {
+      watchArgs.splice(1, 0, `--watch="${path.join("..", "config", "**", "*")}"`);
+    }
     const backendChild = execa(
       tsxBin,
-      ["watch", `--watch="${path.join("..", "config", "**", "*")}"`, "--conditions", "development", "src/index.ts"],
+      watchArgs,
       {
         cwd: backendDir,
         stdio: ["inherit", "pipe", "pipe"],
@@ -967,6 +1058,7 @@ ${chalk.green.bold("Options")}
   ${chalk.blue("--backend-only, -b")}   Only start the backend server
   ${chalk.blue("--frontend-only, -f")}  Only start the frontend server
   ${chalk.blue("--port, -p")}           Backend port (default: auto-detected per project)
+  ${chalk.blue("--generate, -g")}        Enable automatic schema and SDK generation on startup and file changes
 
 ${chalk.green.bold("Description")}
   Starts both the backend (tsx watch + Hono) and frontend (Vite)
@@ -979,6 +1071,10 @@ ${chalk.green.bold("Description")}
   If the assigned port is already in use, the server will automatically
   try the next available port. The frontend is started only after the
   backend is ready, and VITE_API_URL is injected automatically.
+
+  By default, automatic schema and SDK generation is disabled on startup
+  and file changes. Pass --generate (-g) or set REBASE_AUTO_GENERATE=true
+  in your environment to enable it.
 `);
 }
 async function buildCommand() {
@@ -1073,12 +1169,12 @@ async function resetPassword(rawArgs) {
     env.DOTENV_CONFIG_PATH = envFile;
   }
   const scriptContent = `
-import { createPostgresDatabaseConnection } from "@rebasepro/server-core";
-import { hashPassword } from "@rebasepro/server-core/src/auth/password";
+import { createPostgresDatabaseConnection } from "@rebasepro/server-postgresql";
+import { hashPassword } from "@rebasepro/server-core";
 import { eq } from "drizzle-orm";
-import { users } from "@rebasepro/server-core/src/db/auth-schema";
 import * as dotenv from "dotenv";
 import path from "path";
+import fs from "fs";
 
 dotenv.config({ path: "${envFile || path.join(projectRoot, ".env")}" });
 
@@ -1089,12 +1185,30 @@ async function resetPassword() {
     const { db } = createPostgresDatabaseConnection(process.env.DATABASE_URL!);
     const hash = await hashPassword(newPassword);
 
-    const result = await db.update(users)
-        .set({ passwordHash: hash })
-        .where(eq(users.email, email))
+    let usersTable;
+    try {
+        const schemaPath = path.resolve("./src/schema.generated.ts");
+        if (fs.existsSync(schemaPath)) {
+            const schema = await import("file://" + schemaPath);
+            usersTable = schema.users || schema.tables?.users;
+        }
+    } catch (e) {
+        // ignore and fallback
+    }
+
+    if (!usersTable) {
+        const pgServer = await import("@rebasepro/server-postgresql");
+        usersTable = pgServer.users;
+    }
+
+    const passwordHashKey = (usersTable.passwordHash || "passwordHash" in usersTable) ? "passwordHash" : "password_hash";
+
+    const result = await db.update(usersTable)
+        .set({ [passwordHashKey]: hash })
+        .where(eq(usersTable.email, email))
         .returning({
-            id: users.id,
-            email: users.email
+            id: usersTable.id,
+            email: usersTable.email
         });
 
     if (result.length > 0) {