@rebasepro/cli 0.0.1-canary.ca2cb6e → 0.0.1-canary.cbdd980

package/dist/index.es.js

@@ -11,6 +11,45 @@ import crypto from "crypto";
 import { generateSDK } from "@rebasepro/sdk-generator";
 import { execSync, spawn } from "child_process";
 import * as os from "os";
+function detectPackageManager(targetDir) {
+  const userAgent = process.env.npm_config_user_agent ?? "";
+  if (userAgent.startsWith("npm/")) return "npm";
+  if (userAgent.startsWith("pnpm/")) return "pnpm";
+  if (targetDir) {
+    if (fs.existsSync(path.join(targetDir, "package-lock.json"))) return "npm";
+    if (fs.existsSync(path.join(targetDir, "pnpm-lock.yaml"))) return "pnpm";
+  }
+  const cwd = process.cwd();
+  if (cwd !== targetDir) {
+    if (fs.existsSync(path.join(cwd, "package-lock.json"))) return "npm";
+    if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  }
+  return "pnpm";
+}
+function getPMCommands(pm) {
+  if (pm === "npm") {
+    return {
+      name: "npm",
+      install: ["npm", "install"],
+      run: (script) => ["npm", "run", script],
+      exec: (bin, args) => ["npx", bin, ...args],
+      view: (pkg, field) => ["npm", "view", pkg, field],
+      runAll: (script) => ["npm", "run", script, "--workspaces", "--if-present"],
+      runWorkspace: (workspace, script) => ["npm", "run", script, "-w", workspace],
+      workspaceProtocol: "*"
+    };
+  }
+  return {
+    name: "pnpm",
+    install: ["pnpm", "install"],
+    run: (script) => ["pnpm", "run", script],
+    exec: (bin, args) => ["pnpm", "exec", bin, ...args],
+    view: (pkg, field) => ["pnpm", "view", pkg, field],
+    runAll: (script) => ["pnpm", "-r", "run", script],
+    runWorkspace: (workspace, script) => ["pnpm", "--filter", workspace, script],
+    workspaceProtocol: "workspace:*"
+  };
+}
 const access = promisify(fs.access);
 const copy = promisify(ncp);
 const __filename$2 = fileURLToPath(import.meta.url);
@@ -30,10 +69,11 @@ async function createRebaseApp(rawArgs) {
   console.log(`
 ${chalk.bold("Rebase")} — Create a new project 🚀
 `);
-  const options = await promptForOptions(rawArgs);
+  const pm = detectPackageManager();
+  const options = await promptForOptions(rawArgs, pm);
   await createProject(options);
 }
-async function promptForOptions(rawArgs) {
+async function promptForOptions(rawArgs, pm) {
   const args = arg(
     {
       "--git": Boolean,
@@ -76,20 +116,38 @@ async function promptForOptions(rawArgs) {
     questions.push({
       type: "confirm",
       name: "installDeps",
-      message: "Install dependencies with pnpm?",
+      message: `Install dependencies with ${pm}?`,
       default: true
     });
   }
+  questions.push({
+    type: "input",
+    name: "databaseUrl",
+    message: "Enter your PostgreSQL database connection string (leave blank to use a local default):",
+    default: ""
+  });
+  questions.push({
+    type: "confirm",
+    name: "introspect",
+    message: "Would you like to introspect this database to automatically generate collections?",
+    default: true,
+    when: (answers2) => !!answers2.databaseUrl?.trim()
+  });
   const answers = await inquirer.prompt(questions);
   const targetDirectory = path.resolve(process.cwd(), nameArg || answers.projectName);
   const projectName = path.basename(targetDirectory);
   const templateDirectory = path.resolve(cliRoot, "templates", "template");
+  const pmCommands = getPMCommands(pm);
   return {
     projectName,
     git: args["--git"] || answers.git || false,
     installDeps: args["--install"] || answers.installDeps || false,
     targetDirectory,
-    templateDirectory
+    templateDirectory,
+    databaseUrl: answers.databaseUrl?.trim() || void 0,
+    introspect: answers.introspect || false,
+    pm,
+    pmCommands
   };
 }
 async function createProject(options) {
@@ -122,27 +180,7 @@ async function createProject(options) {
     process.exit(1);
   }
   await replacePlaceholders(options);
-  const envTemplatePath = path.join(options.targetDirectory, ".env.template");
-  const envPath = path.join(options.targetDirectory, ".env");
-  if (fs.existsSync(envTemplatePath) && !fs.existsSync(envPath)) {
-    fs.renameSync(envTemplatePath, envPath);
-    const jwtSecret = crypto.randomBytes(32).toString("hex");
-    const dbPassword = crypto.randomBytes(16).toString("hex");
-    let envContent = fs.readFileSync(envPath, "utf-8");
-    envContent = envContent.replace(
-      "postgresql://rebase:password@localhost:5432/rebase",
-      `postgresql://rebase:${dbPassword}@localhost:5432/rebase`
-    );
-    envContent = envContent.replace(
-      "change-this-to-a-secure-random-string",
-      jwtSecret
-    );
-    envContent += `
-# Docker Compose Database Password
-POSTGRES_PASSWORD=${dbPassword}
-`;
-    fs.writeFileSync(envPath, envContent, "utf-8");
-  }
+  configureEnvFile(options.targetDirectory, options.databaseUrl);
   if (options.git) {
     console.log(chalk.gray("  Initializing git repository..."));
     try {
@@ -151,17 +189,40 @@ POSTGRES_PASSWORD=${dbPassword}
       console.warn(chalk.yellow("  Warning: Failed to initialize git repository"));
     }
   }
+  const { pm, pmCommands } = options;
+  const installCmd = pmCommands.install;
+  const execCmd = pmCommands.exec("rebase", ["schema", "introspect", "--force"]);
   if (options.installDeps) {
     console.log("");
-    console.log(chalk.gray("  Installing dependencies with pnpm..."));
+    console.log(chalk.gray(`  Installing dependencies with ${pm}...`));
     console.log("");
     try {
-      await execa("pnpm", ["install"], {
+      await execa(installCmd[0], installCmd.slice(1), {
         cwd: options.targetDirectory,
         stdio: "inherit"
       });
     } catch {
-      console.warn(chalk.yellow("  Warning: Failed to install dependencies. You may need to run `pnpm install` manually."));
+      console.warn(chalk.yellow(`  Warning: Failed to install dependencies. You may need to run \`${installCmd.join(" ")}\` manually.`));
+    }
+  }
+  if (options.introspect) {
+    console.log("");
+    if (options.installDeps) {
+      console.log(chalk.gray("  Introspecting database and generating collections..."));
+      console.log("");
+      try {
+        await execa(execCmd[0], execCmd.slice(1), {
+          cwd: options.targetDirectory,
+          stdio: "inherit"
+        });
+        console.log(chalk.green("  Database successfully introspected!"));
+      } catch {
+        console.warn(chalk.yellow("  Warning: Failed to introspect database automatically."));
+        console.warn(chalk.yellow(`  You can run \`${execCmd.join(" ")}\` manually after setup.`));
+      }
+    } else {
+      console.warn(chalk.yellow("  Skipping introspection because dependencies were not installed."));
+      console.warn(chalk.yellow(`  Run \`${installCmd.join(" ")}\` then \`${execCmd.join(" ")}\` manually.`));
     }
   }
   console.log("");
@@ -169,15 +230,23 @@ POSTGRES_PASSWORD=${dbPassword}
   console.log("");
   console.log(chalk.bold("Next steps:"));
   console.log("");
+  const runDev = pmCommands.run("dev");
   console.log(`  ${chalk.cyan("cd")} ${options.projectName}`);
   if (!options.installDeps) {
-    console.log(`  ${chalk.cyan("pnpm install")}`);
+    console.log(`  ${chalk.cyan(installCmd.join(" "))}`);
   }
   console.log("");
-  console.log(chalk.gray("  # Set up your database connection in .env"));
-  console.log(chalk.gray("  # Then run:"));
+  if (options.databaseUrl) {
+    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("");
+    console.log(chalk.gray("  # Then start the dev server:"));
+  }
   console.log("");
-  console.log(`  ${chalk.cyan("pnpm dev")}`);
+  console.log(`  ${chalk.cyan(runDev.join(" "))}`);
   console.log("");
   console.log(chalk.gray("This starts both the backend (Hono + PostgreSQL)") + chalk.gray(" and the frontend (Vite + React) concurrently."));
   console.log("");
@@ -191,7 +260,8 @@ async function replacePlaceholders(options) {
     "frontend/package.json",
     "backend/package.json",
     "config/package.json",
-    "frontend/index.html"
+    "frontend/index.html",
+    "README.md"
   ];
   const packageJsonPath = path.resolve(cliRoot, "package.json");
   let cliVersion = "latest";
@@ -199,15 +269,84 @@ async function replacePlaceholders(options) {
     const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
     cliVersion = pkg.version || "latest";
   }
+  const versionCache = /* @__PURE__ */ new Map();
+  const viewBin = "npm";
+  const getPackageVersion = async (pkgName) => {
+    if (versionCache.has(pkgName)) return versionCache.get(pkgName);
+    let versionToUse = cliVersion;
+    try {
+      const { stdout } = await 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"]);
+        if (!stdout.trim()) throw new Error("Not found");
+        versionToUse = stdout.trim();
+      } catch {
+        try {
+          const { stdout } = await execa(viewBin, ["view", pkgName, "version"]);
+          versionToUse = stdout.trim() || "latest";
+        } catch {
+          versionToUse = "latest";
+        }
+      }
+    }
+    versionCache.set(pkgName, versionToUse);
+    return versionToUse;
+  };
+  const allPackages = /* @__PURE__ */ new Set();
+  const fileContents = /* @__PURE__ */ new Map();
   for (const file of filesToProcess) {
     const fullPath = path.resolve(options.targetDirectory, file);
     if (!fs.existsSync(fullPath)) continue;
-    let content = fs.readFileSync(fullPath, "utf-8");
-    content = content.replace(/\{\{PROJECT_NAME\}\}/g, options.projectName);
-    content = content.replace(/("@rebasepro\/[^"]+":\s*)"workspace:\*"/g, `$1"${cliVersion}"`);
+    const content = fs.readFileSync(fullPath, "utf-8");
+    fileContents.set(fullPath, content);
+    const matches = [...content.matchAll(/"(@rebasepro\/[^"]+)":\s*"workspace:\*"/g)];
+    for (const match of matches) {
+      allPackages.add(match[1]);
+    }
+  }
+  console.log(chalk.gray("  Resolving package versions..."));
+  await Promise.all(Array.from(allPackages).map(getPackageVersion));
+  for (const [fullPath, originalContent] of fileContents.entries()) {
+    let content = originalContent.replace(/\{\{PROJECT_NAME\}\}/g, options.projectName);
+    const matches = [...content.matchAll(/"(@rebasepro\/[^"]+)":\s*"workspace:\*"/g)];
+    for (const match of matches) {
+      const pkgName = match[1];
+      const resolvedVersion = versionCache.get(pkgName) || "latest";
+      content = content.replace(new RegExp(`"${pkgName}":\\s*"workspace:\\*"`, "g"), `"${pkgName}": "${resolvedVersion}"`);
+    }
     fs.writeFileSync(fullPath, content, "utf-8");
   }
 }
+function configureEnvFile(targetDirectory, databaseUrl) {
+  const envExamplePath = path.join(targetDirectory, ".env.example");
+  const envPath = path.join(targetDirectory, ".env");
+  if (fs.existsSync(envExamplePath) && !fs.existsSync(envPath)) {
+    fs.copyFileSync(envExamplePath, envPath);
+    const jwtSecret = crypto.randomBytes(32).toString("hex");
+    const dbPassword = crypto.randomBytes(16).toString("hex");
+    let envContent = fs.readFileSync(envPath, "utf-8");
+    envContent = envContent.replace(
+      /^JWT_SECRET=.*$/m,
+      `JWT_SECRET=${jwtSecret}`
+    );
+    if (databaseUrl) {
+      envContent = envContent.replace(
+        /^DATABASE_URL=.*$/m,
+        `DATABASE_URL=${databaseUrl}`
+      );
+    } else {
+      envContent = envContent.replace(
+        /^DATABASE_URL=.*$/m,
+        `DATABASE_URL=postgresql://rebase:${dbPassword}@localhost:5432/rebase`
+      );
+    }
+    fs.writeFileSync(envPath, envContent, "utf-8");
+  }
+}
 async function loadCollections(collectionsDir) {
   const absDir = path.resolve(collectionsDir);
   if (!fs.existsSync(absDir)) {
@@ -378,6 +517,7 @@ function resolvePluginCliScript(backendDir, pluginName) {
     path.join(backendDir, "node_modules", pluginName, "src", "cli.ts"),
     path.join(backendDir, "node_modules", pluginName, "dist", "cli.js"),
     // For monorepo dev mode:
+    path.resolve(backendDir, "..", "..", "..", "packages", pluginName.replace("@rebasepro/", ""), "src", "cli.ts"),
     path.resolve(backendDir, "..", "..", "packages", pluginName.replace("@rebasepro/", ""), "src", "cli.ts"),
     path.resolve(backendDir, "..", "packages", pluginName.replace("@rebasepro/", ""), "src", "cli.ts")
   ];
@@ -500,11 +640,15 @@ ${chalk.green.bold("Usage")}
 ${chalk.green.bold("Commands")}
   ${chalk.gray("(Commands are provided by your active database driver plugin)")}
   ${chalk.blue.bold("generate")}    Generate Schema from collection definitions
+  ${chalk.blue.bold("introspect")}  Introspect an existing database to generate collection definitions
 
 ${chalk.green.bold("generate Options")}
   ${chalk.blue("--collections, -c")}  Path to collections directory
   ${chalk.blue("--output, -o")}       Output path for generated schema
   ${chalk.blue("--watch, -w")}        Watch for changes and regenerate automatically
+
+${chalk.green.bold("introspect Options")}
+  ${chalk.blue("--output, -o")}       Output directory for generated collection files
 `);
 }
 async function dbCommand(subcommand, rawArgs) {
@@ -564,7 +708,6 @@ ${chalk.green.bold("Usage")}
 ${chalk.green.bold("Commands")}
   ${chalk.gray("(Commands are provided by your active database driver plugin)")}
   ${chalk.blue.bold("push")}       Apply schema directly to database (development)
-  ${chalk.blue.bold("pull")}       Introspect database → Schema
   ${chalk.blue.bold("generate")}   Generate migration files
   ${chalk.blue.bold("migrate")}    Run pending migrations
   ${chalk.blue.bold("studio")}     Open Studio viewer
@@ -695,9 +838,12 @@ async function devCommand(rawArgs) {
       frontendEnv.VITE_API_URL = `http://localhost:${backendPort}`;
       console.log(`  ${chalk.gray("↳ VITE_API_URL")} = ${chalk.white(`http://localhost:${backendPort}`)}`);
     }
+    const pm = detectPackageManager(projectRoot);
+    const pmCmds = getPMCommands(pm);
+    const runDevCmd = pmCmds.run("dev");
     const frontendChild = execa(
-      "pnpm",
-      ["run", "dev"],
+      runDevCmd[0],
+      runDevCmd.slice(1),
       {
         cwd: frontendDir,
         stdio: ["inherit", "pipe", "pipe"],
@@ -731,8 +877,10 @@ async function devCommand(rawArgs) {
   if (!frontendOnly && backendDir) {
     const tsxBin = resolveTsx(projectRoot);
     if (!tsxBin) {
+      const pmName = detectPackageManager(projectRoot);
+      const addCmd = pmName === "npm" ? "npm install -D tsx" : "pnpm add -D tsx";
       console.error(chalk.red("  ✗ Could not find tsx binary for backend."));
-      console.error(chalk.gray("    Install it with: pnpm add -D tsx"));
+      console.error(chalk.gray(`    Install it with: ${addCmd}`));
       process.exit(1);
     }
     const envFile = findEnvFile(projectRoot);
@@ -833,6 +981,46 @@ ${chalk.green.bold("Description")}
   backend is ready, and VITE_API_URL is injected automatically.
 `);
 }
+async function buildCommand() {
+  const projectRoot = requireProjectRoot();
+  const pm = detectPackageManager(projectRoot);
+  const cmds = getPMCommands(pm);
+  const buildCmd = cmds.runAll("build");
+  console.log(`${chalk.bold("Rebase")} — Building all workspaces with ${chalk.cyan(pm)}...
+`);
+  try {
+    await execa(buildCmd[0], buildCmd.slice(1), {
+      cwd: projectRoot,
+      stdio: "inherit"
+    });
+  } catch {
+    console.error(chalk.red("\n✗ Build failed."));
+    process.exit(1);
+  }
+}
+async function startCommand() {
+  const projectRoot = requireProjectRoot();
+  const pm = detectPackageManager(projectRoot);
+  const cmds = getPMCommands(pm);
+  const startCmd = cmds.runWorkspace("backend", "start");
+  const envFile = findEnvFile(projectRoot);
+  const env = { ...process.env };
+  if (envFile) {
+    env.DOTENV_CONFIG_PATH = envFile;
+  }
+  console.log(`${chalk.bold("Rebase")} — Starting backend server...
+`);
+  try {
+    await execa(startCmd[0], startCmd.slice(1), {
+      cwd: projectRoot,
+      stdio: "inherit",
+      env
+    });
+  } catch {
+    console.error(chalk.red("\n✗ Failed to start server."));
+    process.exit(1);
+  }
+}
 async function authCommand(subcommand, rawArgs) {
   if (!subcommand || subcommand === "--help") {
     printAuthHelp();
@@ -1041,7 +1229,7 @@ async function entry(args) {
   }
   const command = parsedArgs._[0];
   const subcommand = parsedArgs._[1];
-  const namespacedCommands = ["schema", "db", "dev", "auth", "doctor"];
+  const namespacedCommands = ["schema", "db", "dev", "build", "start", "auth", "doctor"];
   if (!command || parsedArgs["--help"] && !namespacedCommands.includes(command)) {
     printHelp();
     return;
@@ -1080,6 +1268,12 @@ async function entry(args) {
     case "dev":
       await devCommand(args);
       break;
+    case "build":
+      await buildCommand();
+      break;
+    case "start":
+      await startCommand();
+      break;
     case "auth":
       await authCommand(effectiveSubcommand, args);
       break;
@@ -1102,14 +1296,16 @@ ${chalk.green.bold("Usage")}
 ${chalk.green.bold("Commands")}
   ${chalk.blue.bold("init")}                    Create a new Rebase project
   ${chalk.blue.bold("dev")}                     Start the development server
+  ${chalk.blue.bold("build")}                   Build all workspace packages
+  ${chalk.blue.bold("start")}                   Start the backend server ${chalk.gray("(production)")}
 
 ${chalk.green.bold("Schema")}
   ${chalk.blue.bold("schema generate")}         Generate Drizzle schema from collections
+  ${chalk.blue.bold("schema introspect")}       Introspect database → Rebase collections
   ${chalk.blue.bold("schema")} ${chalk.gray("--help")}           Show schema command help
 
 ${chalk.green.bold("Database")}
   ${chalk.blue.bold("db push")}                 Apply schema directly to database ${chalk.gray("(dev)")}
-  ${chalk.blue.bold("db pull")}                 Introspect database → Drizzle schema
   ${chalk.blue.bold("db generate")}             Generate SQL migration files
   ${chalk.blue.bold("db migrate")}              Run pending migrations
   ${chalk.blue.bold("db studio")}               Open Drizzle Studio
@@ -1177,6 +1373,8 @@ async function logout(env, _debug) {
 }
 export {
   authCommand,
+  buildCommand,
+  configureEnvFile,
   createRebaseApp,
   dbCommand,
   devCommand,
@@ -1196,6 +1394,7 @@ export {
   resolveLocalBin,
   resolvePluginCliScript,
   resolveTsx,
-  schemaCommand
+  schemaCommand,
+  startCommand
 };
 //# sourceMappingURL=index.es.js.map