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

package/dist/index.es.js

@@ -80,6 +80,19 @@ async function promptForOptions(rawArgs) {
       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);
@@ -89,7 +102,9 @@ async function promptForOptions(rawArgs) {
     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
   };
 }
 async function createProject(options) {
@@ -127,20 +142,27 @@ async function createProject(options) {
   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 += `
+    if (options.databaseUrl) {
+      envContent = envContent.replace(
+        "postgresql://rebase:password@localhost:5432/rebase",
+        options.databaseUrl
+      );
+    } else {
+      const dbPassword = crypto.randomBytes(16).toString("hex");
+      envContent = envContent.replace(
+        "postgresql://rebase:password@localhost:5432/rebase",
+        `postgresql://rebase:${dbPassword}@localhost:5432/rebase`
+      );
+      envContent += `
 # Docker Compose Database Password
 POSTGRES_PASSWORD=${dbPassword}
 `;
+    }
     fs.writeFileSync(envPath, envContent, "utf-8");
   }
   if (options.git) {
@@ -164,6 +186,26 @@ POSTGRES_PASSWORD=${dbPassword}
       console.warn(chalk.yellow("  Warning: Failed to install dependencies. You may need to run `pnpm install` manually."));
     }
   }
+  if (options.introspect) {
+    console.log("");
+    if (options.installDeps) {
+      console.log(chalk.gray("  Introspecting database and generating collections..."));
+      console.log("");
+      try {
+        await execa("pnpm", ["exec", "rebase", "schema", "introspect"], {
+          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 `pnpm exec rebase schema introspect` manually after setup."));
+      }
+    } else {
+      console.warn(chalk.yellow("  Skipping introspection because dependencies were not installed."));
+      console.warn(chalk.yellow("  Run `pnpm install` then `pnpm exec rebase schema introspect` manually."));
+    }
+  }
   console.log("");
   console.log(`${chalk.green.bold("✓")} Project ${chalk.bold(options.projectName)} created successfully!`);
   console.log("");
@@ -174,8 +216,15 @@ POSTGRES_PASSWORD=${dbPassword}
     console.log(`  ${chalk.cyan("pnpm install")}`);
   }
   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("");
@@ -199,12 +248,54 @@ async function replacePlaceholders(options) {
     const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
     cliVersion = pkg.version || "latest";
   }
+  const versionCache = /* @__PURE__ */ new Map();
+  const getPackageVersion = async (pkgName) => {
+    if (versionCache.has(pkgName)) return versionCache.get(pkgName);
+    let versionToUse = cliVersion;
+    try {
+      const { stdout } = await execa("npm", ["--loglevel", "error", "info", `${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("npm", ["--loglevel", "error", "info", `${pkgName}@${tag}`, "version"]);
+        if (!stdout.trim()) throw new Error("Not found");
+        versionToUse = stdout.trim();
+      } catch {
+        try {
+          const { stdout } = await execa("npm", ["--loglevel", "error", "info", 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");
   }
 }
@@ -378,6 +469,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 +592,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) {