@rebasepro/cli 0.1.2 → 0.2.3

package/dist/index.es.js

@@ -3,9 +3,10 @@ import arg from "arg";
 import inquirer from "inquirer";
 import path from "path";
 import fs from "fs";
+import net from "net";
 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 +52,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 +78,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 +92,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 +189,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";
@@ -180,7 +201,7 @@ async function createProject(options) {
     process.exit(1);
   }
   await replacePlaceholders(options);
-  configureEnvFile(options.targetDirectory, options.databaseUrl);
+  await configureEnvFile(options.targetDirectory, options.databaseUrl);
   if (options.git) {
     console.log(chalk.gray("  Initializing git repository..."));
     try {
@@ -240,8 +261,8 @@ async function createProject(options) {
     console.log(chalk.gray("  # Your database is configured! Start the dev server:"));
   } else {
     console.log(chalk.gray("  # A local database configuration has been generated in .env."));
-    console.log(chalk.gray("  # If using the included docker-compose.yml, start it with:"));
-    console.log(`  ${chalk.cyan("docker compose up -d")}`);
+    console.log(chalk.gray("  # If using the included docker-compose.yml, start the database with:"));
+    console.log(`  ${chalk.cyan("docker compose up -d db")}`);
     console.log("");
     console.log(chalk.gray("  # Then start the dev server:"));
   }
@@ -261,6 +282,7 @@ async function replacePlaceholders(options) {
     "backend/package.json",
     "config/package.json",
     "frontend/index.html",
+    "pnpm-workspace.yaml",
     "README.md"
   ];
   const packageJsonPath = path.resolve(cliRoot, "package.json");
@@ -273,6 +295,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"]);
@@ -321,7 +347,26 @@ async function replacePlaceholders(options) {
     fs.writeFileSync(fullPath, content, "utf-8");
   }
 }
-function configureEnvFile(targetDirectory, databaseUrl) {
+async function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once("error", () => {
+      resolve(false);
+    });
+    server.once("listening", () => {
+      server.close(() => resolve(true));
+    });
+    server.listen(port);
+  });
+}
+async function findAvailablePort(startPort) {
+  let port = startPort;
+  while (!await isPortAvailable(port)) {
+    port++;
+  }
+  return port;
+}
+async function configureEnvFile(targetDirectory, databaseUrl) {
   const envExamplePath = path.join(targetDirectory, ".env.example");
   const envPath = path.join(targetDirectory, ".env");
   if (fs.existsSync(envExamplePath) && !fs.existsSync(envPath)) {
@@ -339,10 +384,21 @@ function configureEnvFile(targetDirectory, databaseUrl) {
         `DATABASE_URL=${databaseUrl}`
       );
     } else {
+      const dbPort = await findAvailablePort(5432);
       envContent = envContent.replace(
         /^DATABASE_URL=.*$/m,
-        `DATABASE_URL=postgresql://rebase:${dbPassword}@localhost:5432/rebase`
+        `DATABASE_URL=postgresql://rebase:${dbPassword}@localhost:${dbPort}/rebase?options=-c%20search_path=public
+DATABASE_PASSWORD=${dbPassword}`
       );
+      const dockerComposePath = path.join(targetDirectory, "docker-compose.yml");
+      if (fs.existsSync(dockerComposePath)) {
+        let dockerComposeContent = fs.readFileSync(dockerComposePath, "utf-8");
+        dockerComposeContent = dockerComposeContent.replace(
+          /-\s*"5432:5432"/g,
+          `- "${dbPort}:5432"`
+        );
+        fs.writeFileSync(dockerComposePath, dockerComposeContent, "utf-8");
+      }
     }
     fs.writeFileSync(envPath, envContent, "utf-8");
   }
@@ -440,6 +496,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 +556,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 +631,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 +814,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 +837,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 +857,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 +879,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 +957,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 +1090,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 +1103,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 +1201,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 +1217,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) {