betterstart-cli 0.0.29 → 0.0.30

package/dist/cli.js

@@ -21852,6 +21852,16 @@ function openBrowserVercelNeon() {
     `Opening Vercel... Create a Neon Postgres database, then copy the ${pc.cyan("DATABASE_URL")} from the dashboard.`
   );
 }
+function openBrowserVercelNeonResource(url) {
+  if (!url) {
+    openBrowserVercelNeon();
+    return;
+  }
+  openBrowser(url);
+  p10.log.info(
+    `Opening Vercel... Copy the Neon ${pc.cyan("DATABASE_URL")} from the database dashboard, then paste it below.`
+  );
+}
 async function promptConnectionString() {
   const input = await p10.text({
     message: "Paste your PostgreSQL connection string",
@@ -24655,25 +24665,17 @@ import pc5 from "picocolors";
 var PROVISION_TIMEOUT_MS2 = 18e4;
 var INTERACTIVE_PROVISION_TIMEOUT_MS2 = 6e5;
 async function provisionNeonInteractive(runner, cwd, options) {
-  const addArgs = ["integration", "add", "neon", "--no-env-pull"];
-  if (options.plan) addArgs.push("--plan", options.plan);
   const quietSpinner = spinner2();
   quietSpinner.start("Creating your Neon database");
-  const quiet = await runVercel(runner, addArgs, {
+  const quiet = await runVercel(runner, neonAddArgs(options), {
     cwd,
     mode: "capture",
     timeoutMs: PROVISION_TIMEOUT_MS2,
     env: options.env
   });
   if (quiet.success) {
-    quietSpinner.message("Retrieving the database connection string");
-    const databaseUrl2 = await pullDatabaseUrl(runner, cwd, options.env);
-    if (!databaseUrl2) {
-      quietSpinner.stop("No DATABASE_URL came back from Vercel");
-      return { failure: "env-pull-empty" };
-    }
     quietSpinner.clear();
-    return { databaseUrl: databaseUrl2 };
+    return readNeonProvisionInfo(quiet.stdout);
   }
   quietSpinner.clear();
   p15.log.info(
@@ -24681,7 +24683,7 @@ async function provisionNeonInteractive(runner, cwd, options) {
       "(the Free plan is recommended)."
     )}`
   );
-  const add = await runVercel(runner, addArgs, {
+  const add = await runVercel(runner, connectedNeonAddArgs(options), {
     cwd,
     mode: "inherit",
     timeoutMs: INTERACTIVE_PROVISION_TIMEOUT_MS2,
@@ -24691,21 +24693,19 @@ async function provisionNeonInteractive(runner, cwd, options) {
     return { failure: add.timedOut ? "timeout" : "provision-failed" };
   }
   const pullSpinner = spinner2();
-  pullSpinner.start("Retrieving the database connection string");
-  const databaseUrl = await pullDatabaseUrl(runner, cwd, options.env);
+  pullSpinner.start("Retrieving DATABASE_URL from Vercel");
+  const databaseUrl = await pullVercelEnvValue(runner, cwd, readDbUrlFromDotenv, options.env);
   if (!databaseUrl) {
-    pullSpinner.stop("No DATABASE_URL came back from Vercel");
-    return { failure: "env-pull-empty" };
+    pullSpinner.stop(`${pc5.yellow("\u25B2")} No DATABASE_URL came back from Vercel`);
+    return {};
   }
   pullSpinner.clear();
   return { databaseUrl };
 }
 async function provisionNeon(runner, cwd, options) {
-  const addArgs = ["integration", "add", "neon", "--no-env-pull", "--format", "json"];
-  if (options.plan) addArgs.push("--plan", options.plan);
   const provisionSpinner = spinner2();
   provisionSpinner.start("Creating your Neon database");
-  const add = await runVercel(runner, addArgs, {
+  const add = await runVercel(runner, neonAddArgs(options), {
     cwd,
     mode: "capture",
     timeoutMs: PROVISION_TIMEOUT_MS2,
@@ -24720,33 +24720,49 @@ ${add.stderr}`.trim();
     if (/claim/i.test(combined)) return { failure: "claim-required", detail };
     return { failure: add.timedOut ? "timeout" : "provision-failed", detail };
   }
-  const meta = parseVercelJson(add.stdout);
-  const resourceName = meta?.resourceName ?? meta?.name;
-  provisionSpinner.message("Retrieving the database connection string");
-  const databaseUrl = await pullDatabaseUrl(runner, cwd, options.env);
-  if (!databaseUrl) {
-    provisionSpinner.stop("No DATABASE_URL came back from Vercel");
-    return { resourceName, failure: "env-pull-empty" };
-  }
   provisionSpinner.clear();
-  return { databaseUrl, resourceName };
+  return readNeonProvisionInfo(add.stdout);
 }
-function pullDatabaseUrl(runner, cwd, env) {
-  return pullVercelEnvValue(runner, cwd, readDbUrlFromDotenv, env);
+async function connectNeonResourceToProject(runner, cwd, resourceName, env) {
+  const connect = await runVercel(
+    runner,
+    ["integration", "resource", "connect", resourceName, "--yes", "--format", "json"],
+    { cwd, mode: "capture", timeoutMs: PROVISION_TIMEOUT_MS2, env }
+  );
+  if (connect.success) return { ok: true };
+  const detail = `${connect.stdout}
+${connect.stderr}`.trim();
+  if (/already connected/i.test(detail)) {
+    return { ok: true, alreadyConnected: true, detail: detail || void 0 };
+  }
+  return { ok: false, detail: detail || void 0 };
 }
 function readDbUrlFromDotenv(filePath) {
   const vars = parseDotenvFile(filePath);
   const isPg = (v) => !!v && (v.startsWith("postgres://") || v.startsWith("postgresql://"));
   if (isPg(vars.get("DATABASE_URL"))) return vars.get("DATABASE_URL");
   if (isPg(vars.get("POSTGRES_URL"))) return vars.get("POSTGRES_URL");
-  for (const [key, value] of vars) {
-    if (/DATABASE_URL$/.test(key) && isPg(value)) return value;
-  }
-  for (const value of vars.values()) {
-    if (isPg(value)) return value;
-  }
   return void 0;
 }
+function readNeonProvisionInfo(stdout) {
+  const meta = parseVercelJson(stdout);
+  if (!meta) return {};
+  return {
+    resourceName: meta.resource?.name,
+    dashboardUrl: meta.dashboardUrl,
+    resourceUrl: meta.ssoUrl?.resource
+  };
+}
+function neonAddArgs(options) {
+  const addArgs = ["integration", "add", "neon", "--no-connect", "--format", "json"];
+  if (options.plan) addArgs.push("--plan", options.plan);
+  return addArgs;
+}
+function connectedNeonAddArgs(options) {
+  const addArgs = ["integration", "add", "neon"];
+  if (options.plan) addArgs.push("--plan", options.plan);
+  return addArgs;
+}
 
 // adapters/next/init/vercel/flow.ts
 async function runVercelNeonFlow(options) {
@@ -24762,23 +24778,29 @@ async function runVercelNeonFlow(options) {
       p16.log.warn(authFailureMessage(auth.reason));
       return { ok: false };
     }
-    const projectSpinner = spinner2();
-    projectSpinner.start(`Creating a Vercel project ${pc6.cyan(options.projectName)}`);
-    const project2 = await createVercelProject(runner, options.cwd, options.projectName, env);
-    projectSpinner.stop(
-      project2.linked ? `Linked Vercel project ${pc6.cyan(project2.name)}` : `Using Vercel project ${pc6.cyan(project2.name)}`
-    );
+    await ensureLinkedProject(runner, options.cwd, options.projectName, env);
     const neon = await provisionNeonForMode(runner, options);
-    if (neon.failure || !neon.databaseUrl) {
+    if (neon.failure) {
       p16.log.warn(neonFailureMessage(neon.failure));
       if (neon.detail) p16.log.message(pc6.dim(neon.detail));
       return { ok: false };
     }
+    let databaseUrl = neon.databaseUrl;
+    if (neon.resourceName) {
+      const pulledDatabaseUrl = await connectNeonAndPullDatabaseUrl(
+        runner,
+        options.cwd,
+        neon.resourceName,
+        env
+      );
+      databaseUrl = pulledDatabaseUrl ?? databaseUrl;
+    }
     return {
       ok: true,
-      databaseUrl: neon.databaseUrl,
-      vercelProjectId: project2.projectId,
-      neonResourceName: neon.resourceName
+      databaseUrl,
+      neonResourceName: neon.resourceName,
+      dashboardUrl: neon.dashboardUrl,
+      resourceUrl: neon.resourceUrl
     };
   } catch (error) {
     p16.log.warn(
@@ -24802,16 +24824,7 @@ async function runVercelBlobFlow(options) {
       p16.log.warn(authFailureMessage(auth.reason));
       return { ok: false };
     }
-    let projectId = readLinkedProjectId(options.cwd);
-    if (!projectId) {
-      const projectSpinner = spinner2();
-      projectSpinner.start(`Creating a Vercel project ${pc6.cyan(options.projectName)}`);
-      const project2 = await createVercelProject(runner, options.cwd, options.projectName, env);
-      projectSpinner.stop(
-        project2.linked ? `Linked Vercel project ${pc6.cyan(project2.name)}` : `Using Vercel project ${pc6.cyan(project2.name)}`
-      );
-      projectId = project2.projectId;
-    }
+    await ensureLinkedProject(runner, options.cwd, options.projectName, env);
     const blob = await provisionBlobForMode(runner, options);
     if (blob.failure || !blob.token) {
       p16.log.warn(blobFailureMessage(blob.failure));
@@ -24821,7 +24834,6 @@ async function runVercelBlobFlow(options) {
     return {
       ok: true,
       token: blob.token,
-      vercelProjectId: projectId,
       blobStoreName: blob.storeName
     };
   } catch (error) {
@@ -24847,13 +24859,24 @@ async function runVercelDeployFlow(options) {
       printManualDeployHint();
       return { ok: false };
     }
-    if (!readLinkedProjectId(options.cwd)) {
-      const projectSpinner = spinner2();
-      projectSpinner.start(`Creating a Vercel project ${pc6.cyan(options.projectName)}`);
-      const project2 = await createVercelProject(runner, options.cwd, options.projectName, env);
-      projectSpinner.stop(
-        project2.linked ? `Linked Vercel project ${pc6.cyan(project2.name)}` : `Using Vercel project ${pc6.cyan(project2.name)}`
+    await ensureLinkedProject(runner, options.cwd, options.projectName, env);
+    if (options.neonResourceName) {
+      const neonSpinner = spinner2();
+      neonSpinner.start("Connecting Neon database to Vercel project");
+      const connect = await connectNeonResourceToProject(
+        runner,
+        options.cwd,
+        options.neonResourceName,
+        env
       );
+      if (connect.ok) {
+        neonSpinner.stop(
+          connect.alreadyConnected ? "Neon database already connected to Vercel project" : "Connected Neon database to Vercel project"
+        );
+      } else {
+        neonSpinner.stop(`${pc6.yellow("\u25B2")} Could not connect Neon database to Vercel project`);
+        if (connect.detail) p16.log.message(pc6.dim(connect.detail));
+      }
     }
     const envSpinner = spinner2();
     envSpinner.start("Syncing environment variables to Vercel");
@@ -24908,6 +24931,33 @@ async function runVercelDeployFlow(options) {
 function printManualDeployHint() {
   p16.log.info(`You can deploy manually: ${pc6.cyan("vercel deploy --prod")}`);
 }
+async function ensureLinkedProject(runner, cwd, projectName, env) {
+  if (readLinkedProjectId(cwd)) return;
+  const projectSpinner = spinner2();
+  projectSpinner.start(`Creating a Vercel project ${pc6.cyan(projectName)}`);
+  const project2 = await createVercelProject(runner, cwd, projectName, env);
+  projectSpinner.stop(
+    project2.linked ? `Linked Vercel project ${pc6.cyan(project2.name)}` : `Using Vercel project ${pc6.cyan(project2.name)}`
+  );
+}
+async function connectNeonAndPullDatabaseUrl(runner, cwd, resourceName, env) {
+  const neonSpinner = spinner2();
+  neonSpinner.start("Connecting Neon database to Vercel project");
+  const connect = await connectNeonResourceToProject(runner, cwd, resourceName, env);
+  if (!connect.ok) {
+    neonSpinner.stop(`${pc6.yellow("\u25B2")} Could not connect Neon database to Vercel project`);
+    if (connect.detail) p16.log.message(pc6.dim(connect.detail));
+    return void 0;
+  }
+  neonSpinner.message("Retrieving DATABASE_URL from Vercel");
+  const databaseUrl = await pullVercelEnvValue(runner, cwd, readDbUrlFromDotenv, env);
+  if (!databaseUrl) {
+    neonSpinner.stop(`${pc6.yellow("\u25B2")} No DATABASE_URL came back from Vercel`);
+    return void 0;
+  }
+  neonSpinner.clear();
+  return databaseUrl;
+}
 function provisionBlobForMode(runner, options) {
   const opts = { name: blobStoreName(options.projectName), env: options.env };
   return options.interactive ? provisionBlobStoreInteractive(runner, options.cwd, opts) : provisionBlobStore(runner, options.cwd, opts);
@@ -24954,8 +25004,6 @@ function neonFailureMessage(reason) {
       return "Provisioning needs the Neon marketplace terms accepted \u2014 falling back to manual entry.";
     case "claim-required":
       return "The Neon resource needs to be claimed \u2014 falling back to manual entry.";
-    case "env-pull-empty":
-      return "Provisioned Neon, but no DATABASE_URL came back \u2014 falling back to manual entry.";
     case "timeout":
       return "Neon provisioning timed out \u2014 falling back to manual entry.";
     default:
@@ -25533,6 +25581,7 @@ async function runInitCommand(name, options) {
     isFreshProject = true;
   }
   let databaseUrl;
+  let neonResourceName;
   const existingDbUrl = readExistingDbUrl(cwd);
   if (options.yes) {
     if (options.databaseUrl) {
@@ -25554,9 +25603,23 @@ async function runInitCommand(name, options) {
         env: process.env
       });
       if (flow.ok && flow.databaseUrl) {
+        neonResourceName = flow.neonResourceName;
         databaseUrl = flow.databaseUrl;
         persistDatabaseUrl(cwd, databaseUrl);
         p17.log.success(`Saved DATABASE_URL to ${pc7.cyan(".env.local")}`);
+      } else if (flow.ok) {
+        neonResourceName = flow.neonResourceName;
+        p17.log.warn("Created a Neon database, but DATABASE_URL could not be retrieved from Vercel.");
+        const resourceUrl = flow.resourceUrl ?? flow.dashboardUrl;
+        if (resourceUrl) {
+          p17.log.info(
+            `Open ${pc7.cyan(resourceUrl)} to copy DATABASE_URL, then rerun ${pc7.cyan("betterstart init --database-url <url> --yes")}.`
+          );
+        } else {
+          p17.log.info(
+            `Rerun ${pc7.cyan("betterstart init --database-url <url> --yes")} with a Postgres connection string.`
+          );
+        }
       } else {
         p17.log.warn("Vercel provisioning did not complete; continuing without a database URL.");
       }
@@ -25576,9 +25639,16 @@ async function runInitCommand(name, options) {
         env: process.env
       });
       if (flow.ok && flow.databaseUrl) {
+        neonResourceName = flow.neonResourceName;
         databaseUrl = flow.databaseUrl;
         persistDatabaseUrl(cwd, databaseUrl);
         p17.log.success(`Saved DATABASE_URL to ${pc7.cyan(".env.local")}`);
+      } else if (flow.ok) {
+        neonResourceName = flow.neonResourceName;
+        openBrowserVercelNeonResource(flow.resourceUrl ?? flow.dashboardUrl);
+        databaseUrl = await promptConnectionString();
+        persistDatabaseUrl(cwd, databaseUrl);
+        p17.log.success(`Saved DATABASE_URL to ${pc7.cyan(".env.local")}`);
       } else {
         p17.log.info("Falling back to a manual database connection string.");
         openBrowserVercelNeon();
@@ -26102,10 +26172,15 @@ Run manually: ${pc7.cyan(betterstartExecCommand(pm, "seed"))}`,
         initialValue: linkedVercelProject
       });
       if (!p17.isCancel(deployNow) && deployNow) {
-        await runVercelDeployFlow({ cwd, projectName, env: process.env });
+        await runVercelDeployFlow({ cwd, projectName, neonResourceName, env: process.env });
       }
     } else if (linkedVercelProject && process.env.VERCEL_TOKEN) {
-      const deployFlow = await runVercelDeployFlow({ cwd, projectName, env: process.env });
+      const deployFlow = await runVercelDeployFlow({
+        cwd,
+        projectName,
+        neonResourceName,
+        env: process.env
+      });
       if (!deployFlow.ok) {
         p17.log.warn("Vercel deploy did not complete; continuing.");
       }