@rebasepro/cli 0.0.1-canary.eae7889 → 0.0.1-canary.f81da60

package/dist/index.es.js

@@ -80,16 +80,31 @@ 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 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) {
@@ -122,27 +137,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 {
@@ -164,6 +159,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", "--force"], {
+          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 +189,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("");
@@ -193,14 +215,89 @@ async function replacePlaceholders(options) {
     "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("pnpm", ["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("pnpm", ["view", `${pkgName}@${tag}`, "version"]);
+        if (!stdout.trim()) throw new Error("Not found");
+        versionToUse = stdout.trim();
+      } catch {
+        try {
+          const { stdout } = await execa("pnpm", ["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);
+    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)) {
@@ -371,6 +468,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")
   ];
@@ -493,11 +591,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) {
@@ -1170,6 +1272,7 @@ async function logout(env, _debug) {
 }
 export {
   authCommand,
+  configureEnvFile,
   createRebaseApp,
   dbCommand,
   devCommand,