@rebasepro/cli 0.0.1-canary.d44c30b → 0.0.1-canary.e259309

package/dist/commands/init.d.ts

@@ -4,5 +4,7 @@ export interface InitOptions {
     installDeps: boolean;
     targetDirectory: string;
     templateDirectory: string;
+    databaseUrl?: string;
+    introspect?: boolean;
 }
 export declare function createRebaseApp(rawArgs: string[]): Promise<void>;

package/dist/index.cjs

@@ -89,16 +89,31 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
         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 projectName = nameArg || answers.projectName;
-    const targetDirectory = path.resolve(process.cwd(), projectName);
+    const targetDirectory = path.resolve(process.cwd(), nameArg || answers.projectName);
+    const projectName = path.basename(targetDirectory);
     const templateDirectory = path.resolve(cliRoot, "templates", "template");
     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
     };
   }
   async function createProject(options) {
@@ -136,20 +151,27 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
     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) {
@@ -173,6 +195,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("");
@@ -183,8 +225,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("");
@@ -202,11 +251,60 @@ POSTGRES_PASSWORD=${dbPassword}
       "config/package.json",
       "frontend/index.html"
     ];
+    const packageJsonPath = path.resolve(cliRoot, "package.json");
+    let cliVersion = "latest";
+    if (fs.existsSync(packageJsonPath)) {
+      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);
+      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");
     }
   }
@@ -380,6 +478,7 @@ Expected a default export of EntityCollection[] or an object with named collecti
       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")
     ];
@@ -502,11 +601,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) {