create-nextblock 0.2.19 → 0.2.21

package/bin/create-nextblock.js

@@ -8,7 +8,6 @@ import { fileURLToPath } from 'node:url';
 import { createRequire } from 'node:module';
 import { execa } from 'execa';
 import { program } from 'commander';
-import inquirer from 'inquirer';
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import open from 'open';
@@ -73,23 +72,23 @@ async function handleCommand(projectDirectory, options) {
   try {
     let projectName = projectDirectory;
 
-    if (!projectName) {
-      if (yes) {
-        projectName = DEFAULT_PROJECT_NAME;
-        console.log(chalk.blue(`Using default project name because --yes was provided: ${projectName}`));
-      } else {
-        const answers = await inquirer.prompt([
-          {
-            type: 'input',
-            name: 'projectName',
-            message: 'What is your project named?',
-            default: DEFAULT_PROJECT_NAME,
-          },
-        ]);
-
-        projectName = answers.projectName?.trim() || DEFAULT_PROJECT_NAME;
-      }
-    }
+    if (!projectName) {
+      if (yes) {
+        projectName = DEFAULT_PROJECT_NAME;
+        console.log(chalk.blue(`Using default project name because --yes was provided: ${projectName}`));
+      } else {
+        const projectPrompt = await clack.text({
+          message: 'What is your project named?',
+          initialValue: DEFAULT_PROJECT_NAME,
+          validate: (value) => (!value ? 'Project name is required' : undefined),
+        });
+        if (clack.isCancel(projectPrompt)) {
+          handleWizardCancel('Setup cancelled.');
+        }
+
+        projectName = projectPrompt.trim() || DEFAULT_PROJECT_NAME;
+      }
+    }
 
     const projectDir = resolve(process.cwd(), projectName);
     await ensureEmptyDirectory(projectDir);
@@ -187,10 +186,11 @@ async function runSetupWizard(projectDir, projectName) {
 
   clack.note('Connecting to Supabase...');
   clack.note('I will now open your browser to log into Supabase.');
-  await execa('npx', ['supabase', 'login'], { stdio: 'inherit', cwd: projectPath });
+  await runSupabaseCli(['login'], { cwd: projectPath });
 
+  const assetsState = await ensureSupabaseAssets(projectPath, { required: true, resetProjectRef: true });
   clack.note('Now, please select your NextBlock project when prompted.');
-  await execa('npx', ['supabase', 'link'], { cwd: projectPath, stdio: 'inherit' });
+  await runSupabaseCli(['link'], { cwd: projectPath });
   if (process.stdin.isTTY) {
     try {
       process.stdin.setRawMode(false);
@@ -201,21 +201,14 @@ async function runSetupWizard(projectDir, projectName) {
     process.stdin.resume();
   }
 
-  // Ensure supabase assets exist (config + migrations) after link in case the CLI created/overrode files
-  await ensureSupabaseAssets(projectPath);
-
-  const configTomlPath = resolve(projectPath, 'supabase', 'config.toml');
-  let projectId = null;
+  let projectId = await readSupabaseProjectRef(projectPath);
 
-  if (await fs.pathExists(configTomlPath)) {
-    const configToml = await fs.readFile(configTomlPath, 'utf8');
-    const projectMatch = configToml.match(/project_id\s*=\s*"([^"]+)"/);
-    if (projectMatch?.[1] && !projectMatch[1].includes('env(')) {
-      projectId = projectMatch[1];
-    }
+  if (!projectId && assetsState.projectId) {
+    projectId = assetsState.projectId;
   }
 
   if (!projectId) {
+    clack.note('I could not detect your Supabase project ref automatically.');
     const manual = await clack.text({
       message:
         'Enter your Supabase project ref (from the Supabase dashboard URL or the link output, e.g., abcdefghijklmnopqrstu):',
@@ -227,6 +220,16 @@ async function runSetupWizard(projectDir, projectName) {
     projectId = manual.trim();
   }
 
+  const siteUrlPrompt = await clack.text({
+    message: 'What is the public URL of your site? (NEXT_PUBLIC_URL)',
+    initialValue: 'http://localhost:3000',
+    validate: (val) => (!val ? 'URL is required' : undefined),
+  });
+  if (clack.isCancel(siteUrlPrompt)) {
+    handleWizardCancel('Setup cancelled.');
+  }
+  const siteUrl = siteUrlPrompt.trim();
+
   clack.note('Please go to your Supabase project dashboard to get the following secrets.');
   const supabaseKeys = await clack.group(
     {
@@ -261,11 +264,18 @@ async function runSetupWizard(projectDir, projectName) {
   const postgresUrl = `postgresql://${dbUser}:${dbPassword}@${dbHost}:5432/${dbName}`;
 
   const envPath = resolve(projectPath, '.env');
+  const appendEnvBlock = async (label, lines) => {
+    const normalized = lines.join('\n');
+    const blockContent = normalized.endsWith('\n') ? normalized : `${normalized}\n`;
+    if (canWriteEnv) {
+      await fs.appendFile(envPath, blockContent);
+    } else {
+      clack.note(`Add the following ${label} values to your existing .env:\n${blockContent}`);
+    }
+  };
   const envLines = [
-    '# NextBlock core',
-    'NEXT_PUBLIC_URL=http://localhost:3000',
-    '',
-    '# Supabase',
+    `NEXT_PUBLIC_URL=${siteUrl}`,
+    '# Vercel / Supabase',
     `SUPABASE_PROJECT_ID=${projectId}`,
     `NEXT_PUBLIC_SUPABASE_URL=${supabaseUrl}`,
     `NEXT_PUBLIC_SUPABASE_ANON_KEY=${supabaseKeys.anonKey}`,
@@ -332,6 +342,15 @@ async function runSetupWizard(projectDir, projectName) {
   if (clack.isCancel(setupR2)) {
     handleWizardCancel('Setup cancelled.');
   }
+
+  let r2Values = {
+    publicBaseUrl: '',
+    accountId: '',
+    bucketName: '',
+    accessKey: '',
+    secretKey: '',
+  };
+
   if (setupR2) {
     clack.note('I will open your browser to the R2 dashboard.\nYou need to create a bucket and an R2 API Token.');
     await open('https://dash.cloudflare.com/?to=/:account/r2', { wait: false });
@@ -367,22 +386,29 @@ async function runSetupWizard(projectDir, projectName) {
       { onCancel: () => handleWizardCancel('Setup cancelled.') },
     );
 
-    const r2Env = [
-      '# Cloudflare R2',
-      `NEXT_PUBLIC_R2_BASE_URL=${r2Keys.publicBaseUrl}`,
-      `R2_ACCOUNT_ID=${r2Keys.accountId}`,
-      `R2_BUCKET_NAME=${r2Keys.bucketName}`,
-      `R2_ACCESS_KEY_ID=${r2Keys.accessKey}`,
-      `R2_SECRET_ACCESS_KEY=${r2Keys.secretKey}`,
-      '',
-    ].join('\n');
+    r2Values = {
+      publicBaseUrl: r2Keys.publicBaseUrl,
+      accountId: r2Keys.accountId,
+      bucketName: r2Keys.bucketName,
+      accessKey: r2Keys.accessKey,
+      secretKey: r2Keys.secretKey,
+    };
+  }
 
-    if (canWriteEnv) {
-      await fs.appendFile(envPath, r2Env);
-      clack.note('Cloudflare R2 configuration saved!');
-    } else {
-      clack.note('Add the following R2 values to your existing .env:\n' + r2Env);
-    }
+  await appendEnvBlock('Cloudflare R2', [
+    '',
+    '# Cloudflare',
+    `NEXT_PUBLIC_R2_BASE_URL=${r2Values.publicBaseUrl}`,
+    `R2_ACCOUNT_ID=${r2Values.accountId}`,
+    `R2_BUCKET_NAME=${r2Values.bucketName}`,
+    `R2_ACCESS_KEY_ID=${r2Values.accessKey}`,
+    `R2_SECRET_ACCESS_KEY=${r2Values.secretKey}`,
+    '',
+  ]);
+  if (setupR2) {
+    clack.note('Cloudflare R2 configuration saved!');
+  } else if (canWriteEnv) {
+    clack.note('Cloudflare R2 placeholders added to .env. Configure them later when ready.');
   }
 
   const setupSMTP = await clack.confirm({
@@ -391,6 +417,16 @@ async function runSetupWizard(projectDir, projectName) {
   if (clack.isCancel(setupSMTP)) {
     handleWizardCancel('Setup cancelled.');
   }
+
+  let smtpValues = {
+    host: '',
+    port: '',
+    user: '',
+    pass: '',
+    fromEmail: '',
+    fromName: '',
+  };
+
   if (setupSMTP) {
     const smtpKeys = await clack.group(
       {
@@ -428,23 +464,31 @@ async function runSetupWizard(projectDir, projectName) {
       { onCancel: () => handleWizardCancel('Setup cancelled.') },
     );
 
-    const smtpEnv = [
-      '# Email SMTP Configuration',
-      `SMTP_HOST=${smtpKeys.host}`,
-      `SMTP_PORT=${smtpKeys.port}`,
-      `SMTP_USER=${smtpKeys.user}`,
-      `SMTP_PASS=${smtpKeys.pass}`,
-      `SMTP_FROM_EMAIL=${smtpKeys.fromEmail}`,
-      `SMTP_FROM_NAME=${smtpKeys.fromName}`,
-      '',
-    ].join('\n');
+    smtpValues = {
+      host: smtpKeys.host,
+      port: smtpKeys.port,
+      user: smtpKeys.user,
+      pass: smtpKeys.pass,
+      fromEmail: smtpKeys.fromEmail,
+      fromName: smtpKeys.fromName,
+    };
+  }
 
-    if (canWriteEnv) {
-      await fs.appendFile(envPath, smtpEnv);
-      clack.note('SMTP configuration saved!');
-    } else {
-      clack.note('Add the following SMTP values to your existing .env:\n' + smtpEnv);
-    }
+  await appendEnvBlock('SMTP', [
+    '',
+    '# Email SMTP Configuration',
+    `SMTP_HOST=${smtpValues.host}`,
+    `SMTP_PORT=${smtpValues.port}`,
+    `SMTP_USER=${smtpValues.user}`,
+    `SMTP_PASS=${smtpValues.pass}`,
+    `SMTP_FROM_EMAIL=${smtpValues.fromEmail}`,
+    `SMTP_FROM_NAME=${smtpValues.fromName}`,
+    '',
+  ]);
+  if (setupSMTP) {
+    clack.note('SMTP configuration saved!');
+  } else if (canWriteEnv) {
+    clack.note('SMTP placeholders added to .env. Configure them later when ready.');
   }
 
   clack.outro(`🎉 Your NextBlock project ${projectName ? `"${projectName}" ` : ''}is ready!\n\nNext step:\n  npm run dev`);
@@ -674,29 +718,80 @@ SMTP_FROM_NAME=
   await fs.writeFile(destination, placeholder);
 }
 
-async function ensureSupabaseAssets(projectDir) {
+async function ensureSupabaseAssets(projectDir, options = {}) {
+  const { required = false, resetProjectRef = false } = options;
   const destSupabaseDir = resolve(projectDir, 'supabase');
   await fs.ensureDir(destSupabaseDir);
 
   const packageSupabaseDir = await resolvePackageSupabaseDir();
-  const sources = [packageSupabaseDir].filter(Boolean);
-  if (sources.length === 0) {
-    clack.note('Warning: No supabase assets found in installed packages.');
+  if (!packageSupabaseDir) {
+    const message =
+      'Unable to locate supabase assets in @nextblock-cms/db. Please reinstall dependencies and try again.';
+    if (required) {
+      throw new Error(message);
+    } else {
+      clack.note(message);
+      return { migrationsCopied: false, configCopied: false, projectId: null };
+    }
   }
-  for (const sourceSupabaseDir of sources) {
-    const sourceMigrations = resolve(sourceSupabaseDir, 'migrations');
-    const destMigrations = resolve(destSupabaseDir, 'migrations');
-    if (await fs.pathExists(sourceMigrations)) {
-      await fs.copy(sourceMigrations, destMigrations, { overwrite: true, errorOnExist: false });
+
+  let migrationsCopied = false;
+  let configCopied = false;
+  let detectedProjectId = null;
+
+  const sourceConfigPath = resolve(packageSupabaseDir, 'config.toml');
+  const destinationConfigPath = resolve(destSupabaseDir, 'config.toml');
+  if (await fs.pathExists(sourceConfigPath)) {
+    await fs.copy(sourceConfigPath, destinationConfigPath, { overwrite: true, errorOnExist: false });
+    configCopied = true;
+
+    const sourceConfig = await fs.readFile(sourceConfigPath, 'utf8');
+    const configMatch = sourceConfig.match(/project_id\s*=\s*"([^"]+)"/);
+    if (configMatch?.[1] && !configMatch[1].includes('env(')) {
+      detectedProjectId = configMatch[1];
+    }
+  }
+
+  const sourceMigrations = resolve(packageSupabaseDir, 'migrations');
+  const destMigrations = resolve(destSupabaseDir, 'migrations');
+  if (await fs.pathExists(sourceMigrations)) {
+    await fs.copy(sourceMigrations, destMigrations, { overwrite: true, errorOnExist: false });
+    migrationsCopied = true;
+  }
+
+  if (resetProjectRef) {
+    const tempDir = resolve(destSupabaseDir, '.temp');
+    const projectRefPath = resolve(tempDir, 'project-ref');
+    if (await fs.pathExists(projectRefPath)) {
+      await fs.writeFile(projectRefPath, '');
     }
   }
+
+  if (required) {
+    if (!configCopied) {
+      throw new Error('Missing supabase/config.toml in the installed @nextblock-cms/db package.');
+    }
+    if (!migrationsCopied) {
+      throw new Error('Missing supabase/migrations in the installed @nextblock-cms/db package.');
+    }
+  }
+
+  return { migrationsCopied, configCopied, projectId: detectedProjectId };
 }
 
 async function resolvePackageSupabaseDir() {
   try {
     const pkgPath = require.resolve('@nextblock-cms/db/package.json');
     const pkgDir = dirname(pkgPath);
-    const candidates = [resolve(pkgDir, 'supabase'), resolve(pkgDir, 'lib', 'supabase')];
+    const candidateSegments = [
+      'supabase',
+      'src/supabase',
+      'dist/supabase',
+      'dist/libs/db/supabase',
+      'dist/lib/supabase',
+      'lib/supabase',
+    ];
+    const candidates = candidateSegments.map((segment) => resolve(pkgDir, segment));
     for (const candidate of candidates) {
       if (await fs.pathExists(candidate)) {
         return candidate;
@@ -708,6 +803,27 @@ async function resolvePackageSupabaseDir() {
   return null;
 }
 
+async function readSupabaseProjectRef(projectDir) {
+  const configTomlPath = resolve(projectDir, 'supabase', 'config.toml');
+  if (await fs.pathExists(configTomlPath)) {
+    const config = await fs.readFile(configTomlPath, 'utf8');
+    const configMatch = config.match(/project_id\s*=\s*"([^"]+)"/);
+    if (configMatch?.[1] && !configMatch[1].includes('env(')) {
+      return configMatch[1];
+    }
+  }
+
+  const projectRefPath = resolve(projectDir, 'supabase', '.temp', 'project-ref');
+  if (await fs.pathExists(projectRefPath)) {
+    const value = (await fs.readFile(projectRefPath, 'utf8')).trim();
+    if (/^[a-z0-9]{20,}$/i.test(value)) {
+      return value;
+    }
+  }
+
+  return null;
+}
+
 async function ensureClientComponents(projectDir) {
   const relativePaths = [
     'components/env-var-warning.tsx',
@@ -1175,11 +1291,11 @@ async function initializeGit(projectDir) {
   }
 }
 
-function runCommand(command, args, options = {}) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      stdio: 'inherit',
-      shell: IS_WINDOWS,
+function runCommand(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: 'inherit',
+      shell: IS_WINDOWS,
       ...options,
     });
 
@@ -1194,10 +1310,33 @@ function runCommand(command, args, options = {}) {
         reject(new Error(`${command} exited with code ${code}`));
       }
     });
-  });
-}
-
-function buildNextConfigContent(editorUtilNames) {
+  });
+}
+
+async function runSupabaseCli(args, options = {}) {
+  const { cwd } = options;
+  return new Promise((resolve, reject) => {
+    const child = spawn('npx', ['supabase', ...args], {
+      cwd,
+      shell: IS_WINDOWS,
+      stdio: 'inherit',
+    });
+
+    child.on('error', (error) => {
+      reject(error);
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`supabase ${args.join(' ')} exited with code ${code}`));
+      }
+    });
+  });
+}
+
+function buildNextConfigContent(editorUtilNames) {
   const aliasLines = [];
 
   for (const moduleName of UI_PROXY_MODULES) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-nextblock",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "description": "",
   "main": "index.js",
   "bin": {