@rebasepro/cli 0.1.2 → 0.2.3

package/dist/index.cjs

@@ -1,6 +1,6 @@
 (function(global, factory) {
-  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("chalk"), require("arg"), require("inquirer"), require("path"), require("fs"), require("util"), require("execa"), require("ncp"), require("url"), require("crypto"), require("@rebasepro/sdk-generator"), require("child_process"), require("os")) : typeof define === "function" && define.amd ? define(["exports", "chalk", "arg", "inquirer", "path", "fs", "util", "execa", "ncp", "url", "crypto", "@rebasepro/sdk-generator", "child_process", "os"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["Rebase CLI"] = {}, global.chalk, global.arg, global.inquirer, global.path, global.fs, global.util, global.execa, global.ncp, global.url, global.crypto, global.sdkGenerator, global.child_process, global.os));
-})(this, (function(exports2, chalk, arg, inquirer, path, fs, util, execa, ncp, url, crypto, sdkGenerator, child_process, os) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("chalk"), require("arg"), require("inquirer"), require("path"), require("fs"), require("net"), require("util"), require("execa"), require("fs/promises"), require("url"), require("crypto"), require("@rebasepro/sdk-generator"), require("child_process"), require("os")) : typeof define === "function" && define.amd ? define(["exports", "chalk", "arg", "inquirer", "path", "fs", "net", "util", "execa", "fs/promises", "url", "crypto", "@rebasepro/sdk-generator", "child_process", "os"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["Rebase CLI"] = {}, global.chalk, global.arg, global.inquirer, global.path, global.fs, global.net, global.util, global.execa, global.promises, global.url, global.crypto, global.sdkGenerator, global.child_process, global.os));
+})(this, (function(exports2, chalk, arg, inquirer, path, fs, net, util, execa, promises, url, crypto, sdkGenerator, child_process, os) {
   "use strict";
   var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
   function _interopNamespaceDefault(e) {
@@ -60,7 +60,6 @@
     };
   }
   const access = util.promisify(fs.access);
-  const copy = util.promisify(ncp);
   const __filename$2 = url.fileURLToPath(typeof document === "undefined" && typeof location === "undefined" ? require("url").pathToFileURL(__filename).href : typeof document === "undefined" ? location.href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("index.cjs", document.baseURI).href);
   const __dirname$2 = path.dirname(__filename$2);
   function findParentDir(currentDir, targetName) {
@@ -87,8 +86,12 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
       {
         "--git": Boolean,
         "--install": Boolean,
+        "--database-url": String,
+        "--introspect": Boolean,
+        "--yes": Boolean,
         "-g": "--git",
-        "-i": "--install"
+        "-i": "--install",
+        "-y": "--yes"
       },
       {
         argv: rawArgs.slice(3),
@@ -97,6 +100,24 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
       }
     );
     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({
@@ -176,9 +197,8 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
     }
     console.log(chalk.gray("  Copying project files..."));
     try {
-      await copy(options.templateDirectory, options.targetDirectory, {
-        clobber: false,
-        dot: true,
+      await promises.cp(options.templateDirectory, options.targetDirectory, {
+        recursive: true,
         filter: (source) => {
           const basename = path.basename(source);
           return basename !== "node_modules" && basename !== ".DS_Store";
@@ -189,11 +209,11 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
       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 {
-        await execa("git", ["init"], { cwd: options.targetDirectory });
+        await execa.execa("git", ["init"], { cwd: options.targetDirectory });
       } catch {
         console.warn(chalk.yellow("  Warning: Failed to initialize git repository"));
       }
@@ -206,7 +226,7 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
       console.log(chalk.gray(`  Installing dependencies with ${pm}...`));
       console.log("");
       try {
-        await execa(installCmd[0], installCmd.slice(1), {
+        await execa.execa(installCmd[0], installCmd.slice(1), {
           cwd: options.targetDirectory,
           stdio: "inherit"
         });
@@ -220,7 +240,7 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
         console.log(chalk.gray("  Introspecting database and generating collections..."));
         console.log("");
         try {
-          await execa(execCmd[0], execCmd.slice(1), {
+          await execa.execa(execCmd[0], execCmd.slice(1), {
             cwd: options.targetDirectory,
             stdio: "inherit"
           });
@@ -249,8 +269,8 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
       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:"));
     }
@@ -270,6 +290,7 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
       "backend/package.json",
       "config/package.json",
       "frontend/index.html",
+      "pnpm-workspace.yaml",
       "README.md"
     ];
     const packageJsonPath = path.resolve(cliRoot, "package.json");
@@ -282,20 +303,24 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
     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"]);
+        const { stdout } = await execa.execa(viewBin, ["view", `${pkgName}@${cliVersion}`, "version"]);
         if (!stdout.trim()) throw new Error("Not found");
         versionToUse = stdout.trim();
       } catch {
         try {
           const tag = cliVersion.includes("canary") ? "canary" : "latest";
-          const { stdout } = await execa(viewBin, ["view", `${pkgName}@${tag}`, "version"]);
+          const { stdout } = await execa.execa(viewBin, ["view", `${pkgName}@${tag}`, "version"]);
           if (!stdout.trim()) throw new Error("Not found");
           versionToUse = stdout.trim();
         } catch {
           try {
-            const { stdout } = await execa(viewBin, ["view", pkgName, "version"]);
+            const { stdout } = await execa.execa(viewBin, ["view", pkgName, "version"]);
             versionToUse = stdout.trim() || "latest";
           } catch {
             versionToUse = "latest";
@@ -330,7 +355,26 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
       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)) {
@@ -348,10 +392,21 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
           `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");
     }
@@ -449,6 +504,7 @@ Expected a default export of EntityCollection[] or an object with named collecti
     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);
@@ -508,15 +564,20 @@ Expected a default export of EntityCollection[] or an object with named collecti
     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;
@@ -578,7 +639,7 @@ Expected a default export of EntityCollection[] or an object with named collecti
     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;
@@ -623,13 +684,13 @@ Expected a default export of EntityCollection[] or an object with named collecti
           console.error(chalk.red("✗ Could not find tsx binary."));
           process.exit(1);
         }
-        await execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
+        await execa.execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
           cwd: backendDir,
           stdio: "inherit",
           env
         });
       } else {
-        await execa("node", [pluginCli, ...rawArgs.slice(2)], {
+        await execa.execa("node", [pluginCli, ...rawArgs.slice(2)], {
           cwd: backendDir,
           stdio: "inherit",
           env
@@ -691,13 +752,13 @@ ${chalk.green.bold("introspect Options")}
           console.error(chalk.red("✗ Could not find tsx binary."));
           process.exit(1);
         }
-        await execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
+        await execa.execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
           cwd: backendDir,
           stdio: "inherit",
           env
         });
       } else {
-        await execa("node", [pluginCli, ...rawArgs.slice(2)], {
+        await execa.execa("node", [pluginCli, ...rawArgs.slice(2)], {
           cwd: backendDir,
           stdio: "inherit",
           env
@@ -761,10 +822,12 @@ ${chalk.green.bold("Examples")}
         "--backend-only": Boolean,
         "--frontend-only": Boolean,
         "--port": Number,
+        "--generate": Boolean,
         "--help": Boolean,
         "-b": "--backend-only",
         "-f": "--frontend-only",
         "-p": "--port",
+        "-g": "--generate",
         "-h": "--help"
       },
       {
@@ -782,6 +845,7 @@ ${chalk.green.bold("Examples")}
     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"));
@@ -801,10 +865,10 @@ ${chalk.green.bold("Examples")}
         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("");
@@ -823,7 +887,7 @@ ${chalk.green.bold("Examples")}
         if (child.pid && !child.killed) {
           try {
             if (process.platform === "win32") {
-              execa.commandSync(`taskkill /pid ${child.pid} /T /F`);
+              execa.execaCommandSync(`taskkill /pid ${child.pid} /T /F`);
             } else {
               process.kill(-child.pid, "SIGKILL");
             }
@@ -850,7 +914,7 @@ ${chalk.green.bold("Examples")}
       const pm = detectPackageManager(projectRoot);
       const pmCmds = getPMCommands(pm);
       const runDevCmd = pmCmds.run("dev");
-      const frontendChild = execa(
+      const frontendChild = execa.execa(
         runDevCmd[0],
         runDevCmd.slice(1),
         {
@@ -901,9 +965,67 @@ ${chalk.green.bold("Examples")}
       console.log(`  ${chalk.cyan("▶")} Backend:  ${chalk.gray(backendDir)}`);
       console.log(`  ${chalk.gray("↳ PORT")} = ${chalk.white(String(startPort))}`);
       let frontendLaunched = false;
-      const backendChild = execa(
+      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.execa(tsxBin, [pluginCli, "schema", "generate"], {
+              cwd: backendDir,
+              stdio: "inherit",
+              env
+            });
+          }
+          await execa.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.execa(tsxBin, [pluginCli, "schema", "generate"], {
+                    cwd: backendDir,
+                    stdio: "inherit",
+                    env
+                  });
+                }
+                await execa.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.execa(
         tsxBin,
-        ["watch", `--watch="${path.join("..", "config", "**", "*")}"`, "--conditions", "development", "src/index.ts"],
+        watchArgs,
         {
           cwd: backendDir,
           stdio: ["inherit", "pipe", "pipe"],
@@ -976,6 +1098,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)
@@ -988,6 +1111,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() {
@@ -998,7 +1125,7 @@ ${chalk.green.bold("Description")}
     console.log(`${chalk.bold("Rebase")} — Building all workspaces with ${chalk.cyan(pm)}...
 `);
     try {
-      await execa(buildCmd[0], buildCmd.slice(1), {
+      await execa.execa(buildCmd[0], buildCmd.slice(1), {
         cwd: projectRoot,
         stdio: "inherit"
       });
@@ -1020,7 +1147,7 @@ ${chalk.green.bold("Description")}
     console.log(`${chalk.bold("Rebase")} — Starting backend server...
 `);
     try {
-      await execa(startCmd[0], startCmd.slice(1), {
+      await execa.execa(startCmd[0], startCmd.slice(1), {
         cwd: projectRoot,
         stdio: "inherit",
         env
@@ -1082,12 +1209,12 @@ ${chalk.green.bold("Description")}
       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")}" });
 
@@ -1098,12 +1225,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) {
@@ -1191,13 +1336,13 @@ ${chalk.green.bold("Examples")}
           console.error(chalk.red("✗ Could not find tsx binary."));
           process.exit(1);
         }
-        await execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
+        await execa.execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
           cwd: backendDir,
           stdio: "inherit",
           env
         });
       } else {
-        await execa("node", [pluginCli, ...rawArgs.slice(2)], {
+        await execa.execa("node", [pluginCli, ...rawArgs.slice(2)], {
           cwd: backendDir,
           stdio: "inherit",
           env