abw-react-starter 1.0.1 → 1.0.3

package/bin/create.js

@@ -35,6 +35,32 @@ async function runCapture(cmd, args, opts = {}) {
   return p.stdout?.trim();
 }
 
+async function runCombined(cmd, args, opts = {}) {
+  try {
+    const result = await execa(cmd, args, {
+      all: true,
+      ...opts,
+    });
+
+    return {
+      ok: true,
+      code: 0,
+      output: result.all?.trim() || "",
+      stdout: result.stdout?.trim() || "",
+      stderr: result.stderr?.trim() || "",
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      code: err?.exitCode ?? 1,
+      output: String(err?.all || err?.stderr || err?.stdout || err?.message || "").trim(),
+      stdout: String(err?.stdout || "").trim(),
+      stderr: String(err?.stderr || "").trim(),
+      error: err,
+    };
+  }
+}
+
 function ensureNoTrailingSlash(url) {
   return (url || "").replace(/\/+$/, "");
 }
@@ -47,9 +73,15 @@ async function assertCmdExists(cmd, args = ["--version"]) {
   }
 }
 
-function looksLikeHerokuNameTakenError(err) {
-  const msg = String(err?.stderr || err?.shortMessage || err?.message || "").toLowerCase();
-  return msg.includes("name") && (msg.includes("taken") || msg.includes("already exists"));
+function looksLikeHerokuNameTakenError(output) {
+  const msg = String(output || "").toLowerCase();
+  return (
+    msg.includes("name") &&
+    (msg.includes("taken") ||
+      msg.includes("already taken") ||
+      msg.includes("already exists") ||
+      msg.includes("invalid_params"))
+  );
 }
 
 async function getHerokuAppInfo(appName, cwd) {
@@ -57,6 +89,14 @@ async function getHerokuAppInfo(appName, cwd) {
   return JSON.parse(raw || "{}");
 }
 
+async function tryCreateHerokuApp(appName, region, cwd) {
+  const args = ["create"];
+  if (appName) args.push(appName);
+  args.push("--region", region);
+
+  return runCombined("heroku", args, { cwd });
+}
+
 async function createHerokuAppWithFallback({ cwd, requestedName, region, label }) {
   const attempts = [];
 
@@ -67,24 +107,40 @@ async function createHerokuAppWithFallback({ cwd, requestedName, region, label }
   }
 
   for (const candidate of attempts) {
-    try {
-      console.log(`\n=== ${label}: tentar criar app Heroku "${candidate}" ===\n`);
-      await run("heroku", ["create", candidate, "--region", region], { cwd });
+    console.log(`\n=== ${label}: tentar criar app Heroku "${candidate}" ===\n`);
+
+    const res = await tryCreateHerokuApp(candidate, region, cwd);
+
+    if (res.output) {
+      console.log(res.output);
+    }
+
+    if (res.ok) {
       return candidate;
-    } catch (err) {
-      if (looksLikeHerokuNameTakenError(err)) {
-        console.log(`⚠️ Nome já ocupado: ${candidate}`);
-        continue;
-      }
-      throw err;
     }
+
+    if (looksLikeHerokuNameTakenError(res.output)) {
+      console.log(`⚠️ Nome já ocupado: ${candidate}`);
+      continue;
+    }
+
+    throw res.error || new Error(`Falha ao criar app Heroku (${label}).`);
   }
 
   console.log(`\n=== ${label}: a criar app Heroku com nome automático ===\n`);
-  await run("heroku", ["create", "--region", region], { cwd });
 
-  const whoRaw = await runCapture("heroku", ["apps", "--json"], { cwd });
-  const apps = JSON.parse(whoRaw || "[]");
+  const autoRes = await tryCreateHerokuApp(null, region, cwd);
+
+  if (autoRes.output) {
+    console.log(autoRes.output);
+  }
+
+  if (!autoRes.ok) {
+    throw autoRes.error || new Error(`Falha ao criar app Heroku com nome automático (${label}).`);
+  }
+
+  const appsRaw = await runCapture("heroku", ["apps", "--json"], { cwd });
+  const apps = JSON.parse(appsRaw || "[]");
 
   if (!Array.isArray(apps) || apps.length === 0) {
     throw new Error(`Não consegui descobrir o nome final da app Heroku (${label}).`);
@@ -104,8 +160,47 @@ async function createHerokuAppWithFallback({ cwd, requestedName, region, label }
   return latest;
 }
 
+function upsertEnvValue(content, key, value) {
+  const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(`^${escapedKey}=.*$`, "m");
+  const line = `${key}=${value}`;
+
+  if (regex.test(content)) {
+    return content.replace(regex, line);
+  }
+
+  const trimmed = content.replace(/\s*$/, "");
+  return trimmed ? `${trimmed}\n${line}\n` : `${line}\n`;
+}
+
+async function mergeEnvFile(filePath, values) {
+  let content = "";
+
+  if (await fs.pathExists(filePath)) {
+    content = await fs.readFile(filePath, "utf8");
+  }
+
+  for (const [key, value] of Object.entries(values)) {
+    content = upsertEnvValue(content, key, value ?? "");
+  }
+
+  await fs.writeFile(filePath, content);
+}
+
+async function commitAllIfNeeded(cwd, message) {
+  await run("git", ["add", "."], { cwd });
+
+  const status = await runCapture("git", ["status", "--porcelain"], { cwd });
+  if (!status) {
+    console.log("ℹ️ Nada novo para commitar");
+    return;
+  }
+
+  await run("git", ["commit", "-m", message], { cwd });
+}
+
 /* =========================
-   Heroku Login (melhorado)
+   Heroku Login
 ========================= */
 
 async function isHerokuLoggedIn() {
@@ -146,7 +241,8 @@ async function ensureHerokuLoginOrSkip() {
 ========================= */
 
 async function writeManifest(projectDir, data) {
-  await fs.writeJson(path.join(projectDir, MANIFEST_NAME), data, {
+  const current = (await readManifest(projectDir)) || {};
+  await fs.writeJson(path.join(projectDir, MANIFEST_NAME), { ...current, ...data }, {
     spaces: 2,
   });
 }
@@ -179,7 +275,7 @@ async function initGitRepo(cwd, message) {
 }
 
 /* =========================
-   🆕 S3 Setup
+   S3 Setup
 ========================= */
 
 async function configureBackendS3(projectDir, aws) {
@@ -190,6 +286,7 @@ async function configureBackendS3(projectDir, aws) {
 
   const bucketUrl = `https://${aws.bucket}.s3.${aws.region}.amazonaws.com`;
 
+  console.log("\n=== BACKEND: configurar middlewares.ts ===\n");
   await fs.writeFile(
     path.join(beDir, "config", "middlewares.ts"),
     `export default [
@@ -218,6 +315,7 @@ async function configureBackendS3(projectDir, aws) {
 `
   );
 
+  console.log("\n=== BACKEND: configurar plugins.ts ===\n");
   await fs.writeFile(
     path.join(beDir, "config", "plugins.ts"),
     `export default ({ env }) => ({
@@ -248,14 +346,37 @@ async function configureBackendS3(projectDir, aws) {
 `
   );
 
+  console.log("\n=== BACKEND: configurar server.ts ===\n");
   await fs.writeFile(
-    path.join(beDir, ".env"),
-    `AWS_ACCESS_KEY_ID=${aws.key}
-AWS_ACCESS_SECRET=${aws.secret}
-AWS_REGION=${aws.region}
-AWS_BUCKET=${aws.bucket}
+    path.join(beDir, "config", "server.ts"),
+    `import type { Core } from '@strapi/strapi';
+
+const config = ({ env }: Core.Config.Shared.ConfigParams): Core.Config.Server => {
+  return {
+    host: env('HOST', '0.0.0.0'),
+    port: env.int('PORT', 1337),
+    app: {
+      keys: env.array('APP_KEYS'),
+    },
+    transfer: {
+      remote: {
+        enabled: true,
+      },
+    },
+  };
+};
+
+export default config;
 `
   );
+
+  console.log("\n=== BACKEND: atualizar .env ===\n");
+  await mergeEnvFile(path.join(beDir, ".env"), {
+    AWS_ACCESS_KEY_ID: aws.key,
+    AWS_ACCESS_SECRET: aws.secret,
+    AWS_REGION: aws.region,
+    AWS_BUCKET: aws.bucket,
+  });
 }
 
 /* =========================
@@ -286,6 +407,7 @@ async function createBackendLocal(projectDir) {
     cwd: path.join(projectDir, "backend"),
   });
 
+  console.log("\n=== BACKEND: git init/commit ===\n");
   await initGitRepo(path.join(projectDir, "backend"), "Init Strapi backend");
 }
 
@@ -300,6 +422,31 @@ async function createFrontendLocal(projectDir, nodeVersion) {
   });
 
   const feDir = path.join(projectDir, "frontend");
+
+  const nextConfigTs = path.join(feDir, "next.config.ts");
+  const nextConfigJs = path.join(feDir, "next.config.js");
+
+  if (await fs.pathExists(nextConfigTs)) {
+    await fs.remove(nextConfigTs);
+    await fs.writeFile(
+      nextConfigJs,
+      `/** @type {import('next').NextConfig} */
+const nextConfig = {};
+
+module.exports = nextConfig;
+`
+    );
+  } else if (!(await fs.pathExists(nextConfigJs))) {
+    await fs.writeFile(
+      nextConfigJs,
+      `/** @type {import('next').NextConfig} */
+const nextConfig = {};
+
+module.exports = nextConfig;
+`
+    );
+  }
+
   const pkgPath = path.join(feDir, "package.json");
   const pkg = await fs.readJson(pkgPath);
 
@@ -307,10 +454,17 @@ async function createFrontendLocal(projectDir, nodeVersion) {
   pkg.engines.node = nodeVersion;
 
   pkg.scripts = pkg.scripts || {};
+  pkg.scripts.build = pkg.scripts.build || "next build";
   pkg.scripts.start = "next start -p $PORT";
 
   await fs.writeJson(pkgPath, pkg, { spaces: 2 });
 
+  const envLocalPath = path.join(feDir, ".env.local");
+  if (!(await fs.pathExists(envLocalPath))) {
+    await fs.writeFile(envLocalPath, "NEXT_PUBLIC_STRAPI_URL=http://localhost:1337\n");
+  }
+
+  console.log("\n=== FRONTEND: git init/commit ===\n");
   await initGitRepo(feDir, "Init Next frontend");
 }
 
@@ -331,6 +485,24 @@ async function deployBackendHeroku({ projectDir, backendApp, region }) {
   await run("heroku", ["git:remote", "-a", finalBackendApp], { cwd: beDir });
   await run("heroku", ["addons:create", "heroku-postgresql", "-a", finalBackendApp], { cwd: beDir });
 
+  console.log("\n=== BACKEND: configurar env vars Strapi ===\n");
+  const appKeys = [randHex(16), randHex(16), randHex(16), randHex(16)].join(",");
+  const apiTokenSalt = randHex(16);
+  const adminJwtSecret = randHex(24);
+  const jwtSecret = randHex(24);
+
+  await run("heroku", ["config:set", `NODE_ENV=production`, "-a", finalBackendApp], { cwd: beDir });
+  await run("heroku", ["config:set", `APP_KEYS=${appKeys}`, "-a", finalBackendApp], { cwd: beDir });
+  await run("heroku", ["config:set", `API_TOKEN_SALT=${apiTokenSalt}`, "-a", finalBackendApp], { cwd: beDir });
+  await run("heroku", ["config:set", `ADMIN_JWT_SECRET=${adminJwtSecret}`, "-a", finalBackendApp], { cwd: beDir });
+  await run("heroku", ["config:set", `JWT_SECRET=${jwtSecret}`, "-a", finalBackendApp], { cwd: beDir });
+
+  await run("heroku", ["config:set", `DATABASE_CLIENT=postgres`, "-a", finalBackendApp], { cwd: beDir });
+  await run("heroku", ["config:set", `DATABASE_SSL=true`, "-a", finalBackendApp], { cwd: beDir });
+  await run("heroku", ["config:set", `DATABASE_SSL_REJECT_UNAUTHORIZED=false`, "-a", finalBackendApp], {
+    cwd: beDir,
+  });
+
   const envPath = path.join(beDir, ".env");
 
   if (await fs.pathExists(envPath)) {
@@ -349,13 +521,21 @@ async function deployBackendHeroku({ projectDir, backendApp, region }) {
       await run("heroku", ["config:set", `AWS_REGION=${awsRegion}`, "-a", finalBackendApp], { cwd: beDir });
     }
     if (awsAccessKeyId) {
-      await run("heroku", ["config:set", `AWS_ACCESS_KEY_ID=${awsAccessKeyId}`, "-a", finalBackendApp], { cwd: beDir });
+      await run("heroku", ["config:set", `AWS_ACCESS_KEY_ID=${awsAccessKeyId}`, "-a", finalBackendApp], {
+        cwd: beDir,
+      });
     }
     if (awsAccessSecret) {
-      await run("heroku", ["config:set", `AWS_ACCESS_SECRET=${awsAccessSecret}`, "-a", finalBackendApp], { cwd: beDir });
+      await run("heroku", ["config:set", `AWS_ACCESS_SECRET=${awsAccessSecret}`, "-a", finalBackendApp], {
+        cwd: beDir,
+      });
     }
   }
 
+  console.log("\n=== BACKEND: garantir commit antes do deploy ===\n");
+  await commitAllIfNeeded(beDir, "Pre-deploy commit");
+
+  console.log("\n=== BACKEND: deploy ===\n");
   await run("git", ["push", "heroku", "main"], { cwd: beDir });
 
   const info = await getHerokuAppInfo(finalBackendApp, beDir);
@@ -387,10 +567,15 @@ async function deployFrontendHeroku({ projectDir, frontendApp, region, backendWe
 
   await run("heroku", ["git:remote", "-a", finalFrontendApp], { cwd: feDir });
 
+  console.log("\n=== FRONTEND: configurar env var ===\n");
   await run("heroku", ["config:set", `NEXT_PUBLIC_STRAPI_URL=${backendWebUrl}`, "-a", finalFrontendApp], {
     cwd: feDir,
   });
 
+  console.log("\n=== FRONTEND: garantir commit antes do deploy ===\n");
+  await commitAllIfNeeded(feDir, "Pre-deploy commit");
+
+  console.log("\n=== FRONTEND: deploy ===\n");
   await run("git", ["push", "heroku", "main"], { cwd: feDir });
 
   const info = await getHerokuAppInfo(finalFrontendApp, feDir);
@@ -422,7 +607,6 @@ async function doCreate(projectDirArg, opts) {
   const region = (opts.region || "eu").toLowerCase();
   const nodeVersion = opts.node || "20.x";
 
-  // S3
   const { useS3 } = await inquirer.prompt([
     { type: "confirm", name: "useS3", message: "Usar S3?", default: true },
   ]);
@@ -432,9 +616,9 @@ async function doCreate(projectDirArg, opts) {
   if (useS3) {
     aws = await inquirer.prompt([
       { name: "bucket", message: "Bucket:" },
-      { name: "region", default: "eu-north-1" },
+      { name: "region", message: "Region:", default: "eu-north-1" },
       { name: "key", message: "Access Key:" },
-      { type: "password", name: "secret", message: "Secret:" },
+      { type: "password", name: "secret", message: "Secret:", mask: "*" },
     ]);
   }
 
@@ -456,7 +640,12 @@ async function doCreate(projectDirArg, opts) {
 
   await createBackendLocal(projectDir);
 
-  if (useS3) await configureBackendS3(projectDir, aws);
+  if (useS3 && aws) {
+    await configureBackendS3(projectDir, aws);
+
+    console.log("\n=== BACKEND: commit configs S3 ===\n");
+    await commitAllIfNeeded(path.join(projectDir, "backend"), "Configure S3 upload");
+  }
 
   await createFrontendLocal(projectDir, nodeVersion);
 
@@ -467,31 +656,93 @@ async function doCreate(projectDirArg, opts) {
     backendApp,
     frontendApp,
     useS3,
-    awsBucket: aws?.bucket,
-    awsRegion: aws?.region,
+    awsBucket: aws?.bucket || null,
+    awsRegion: aws?.region || null,
     createdAt: new Date().toISOString(),
+    deployedAt: null,
+    backendUrl: null,
+    frontendUrl: null,
   });
 
-  if (!deployNow) return;
+  if (!deployNow) {
+    console.log("\n✅ Projeto criado localmente (sem Heroku).");
+    console.log(`📁 Pasta: ${projectDir}`);
+    console.log("\nPara correr local:");
+    console.log("- Backend: cd backend && npm run develop");
+    console.log("- Frontend: cd frontend && npm run dev");
+    console.log("\nQuando quiseres publicar:");
+    console.log(`- abw-react-starter publish "${projectDir}"`);
+    return;
+  }
+
+  const publishAnswers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "backendApp",
+      message: "Nome da app Heroku do backend (Strapi):",
+      default: backendApp,
+      validate: (v) => (v?.length >= 3 ? true : "Nome muito curto"),
+    },
+    {
+      type: "input",
+      name: "frontendApp",
+      message: "Nome da app Heroku do frontend (Next):",
+      default: frontendApp,
+      validate: (v) => (v?.length >= 3 ? true : "Nome muito curto"),
+    },
+    {
+      type: "confirm",
+      name: "confirm",
+      message: "Confirmas criar 2 apps Heroku e fazer deploy?",
+      default: true,
+    },
+  ]);
+
+  if (!publishAnswers.confirm) {
+    console.log("\n✅ Projeto criado localmente (não publicaste no Heroku).");
+    console.log(`Quando quiseres publicar: abw-react-starter publish "${projectDir}"`);
+    return;
+  }
+
+  backendApp = publishAnswers.backendApp;
+  frontendApp = publishAnswers.frontendApp;
+
+  await writeManifest(projectDir, {
+    backendApp,
+    frontendApp,
+  });
 
   const canPublish = await ensureHerokuLoginOrSkip();
-  if (!canPublish) return;
 
-  await doPublish(projectDir);
+  if (!canPublish) {
+    console.log("\n✅ Projeto criado localmente (sem publicar no Heroku).");
+    console.log(`📁 Pasta: ${projectDir}`);
+    console.log("\nPara publicar mais tarde:");
+    console.log(`- abw-react-starter publish "${projectDir}"`);
+    return;
+  }
+
+  await doPublish(projectDir, { skipHerokuLoginCheck: true });
 }
 
 /* =========================
    Publish
 ========================= */
 
-async function doPublish(projectDirArg) {
+async function doPublish(projectDirArg, options = {}) {
+  const { skipHerokuLoginCheck = false } = options;
   const projectDir = resolveProjectDir(projectDirArg);
 
   await assertCmdExists("git");
   await assertCmdExists("heroku");
 
-  const canPublish = await ensureHerokuLoginOrSkip();
-  if (!canPublish) return;
+  if (!skipHerokuLoginCheck) {
+    const canPublish = await ensureHerokuLoginOrSkip();
+    if (!canPublish) {
+      console.log("\nℹ️ Publicação cancelada. O projeto continua localmente sem deploy no Heroku.");
+      return;
+    }
+  }
 
   const manifest = await readManifest(projectDir);
   if (!manifest) {
@@ -500,21 +751,59 @@ async function doPublish(projectDirArg) {
     );
   }
 
+  const region = (manifest.region || "eu").toLowerCase();
+  const backendDir = path.join(projectDir, "backend");
+  const frontendDir = path.join(projectDir, "frontend");
+
+  if (!(await fs.pathExists(backendDir))) throw new Error("Não encontrei a pasta backend.");
+  if (!(await fs.pathExists(frontendDir))) throw new Error("Não encontrei a pasta frontend.");
+
+  let backendApp = manifest.backendApp;
+  let frontendApp = manifest.frontendApp;
+
+  if (!backendApp || !frontendApp) {
+    const projectBase = path.basename(projectDir);
+    const a = await inquirer.prompt([
+      {
+        type: "input",
+        name: "backendApp",
+        message: "Nome da app Heroku do backend (Strapi):",
+        default: backendApp || `${projectBase}-api`,
+        validate: (v) => (v?.length >= 3 ? true : "Nome muito curto"),
+      },
+      {
+        type: "input",
+        name: "frontendApp",
+        message: "Nome da app Heroku do frontend (Next):",
+        default: frontendApp || `${projectBase}-web`,
+        validate: (v) => (v?.length >= 3 ? true : "Nome muito curto"),
+      },
+    ]);
+
+    backendApp = a.backendApp;
+    frontendApp = a.frontendApp;
+
+    await writeManifest(projectDir, {
+      backendApp,
+      frontendApp,
+    });
+  }
+
   const backendResult = await deployBackendHeroku({
     projectDir,
-    backendApp: manifest.backendApp,
-    region: manifest.region,
+    backendApp,
+    region,
   });
 
   const frontendResult = await deployFrontendHeroku({
     projectDir,
-    frontendApp: manifest.frontendApp,
-    region: manifest.region,
+    frontendApp,
+    region,
     backendWebUrl: backendResult.backendWebUrl,
   });
 
   await writeManifest(projectDir, {
-    ...manifest,
+    deployedAt: new Date().toISOString(),
     backendApp: backendResult.backendApp,
     frontendApp: frontendResult.frontendApp,
     backendUrl: backendResult.backendWebUrl,
@@ -522,45 +811,57 @@ async function doPublish(projectDirArg) {
   });
 
   console.log("\n✅ Tudo pronto!");
-  console.log("Backend app:", backendResult.backendApp);
-  console.log("Backend:", backendResult.backendWebUrl);
-  console.log("Frontend app:", frontendResult.frontendApp);
-  console.log("Frontend:", frontendResult.frontendWebUrl);
+  console.log(`Backend app: ${backendResult.backendApp}`);
+  console.log(`Backend (Strapi): ${backendResult.backendWebUrl}`);
+  console.log(`Admin: ${backendResult.backendWebUrl}/admin`);
+  console.log(`Frontend app: ${frontendResult.frontendApp}`);
+  console.log(`Frontend (Next): ${frontendResult.frontendWebUrl}`);
+  console.log("\nNotas:");
+  console.log("- Content types normalmente crias localmente e depois fazes push para o backend Heroku.");
+  console.log("- Em produção, dá permissões em Public role para expor endpoints.");
 }
 
 /* =========================
-   CLI (INALTERADO)
+   CLI
 ========================= */
 
 program.name("abw-react-starter");
 
+// Comando create (default)
 program
   .command("create")
-  .argument("<projectDir>")
-  .option("--backend-app <name>")
-  .option("--frontend-app <name>")
-  .option("--node <version>", "20.x")
-  .option("--region <region>", "eu")
+  .argument("<projectDir>", "Diretório do projeto (será criado)")
+  .option("--backend-app <name>", "Nome da app Heroku do backend (Strapi)")
+  .option("--frontend-app <name>", "Nome da app Heroku do frontend (Next)")
+  .option("--node <version>", "Versão Node para Heroku (ex: 20.x)", "20.x")
+  .option("--region <region>", "Heroku region (eu | us)", "eu")
   .action(async (projectDirArg, opts) => {
     await doCreate(projectDirArg, opts);
   });
 
+// Para compatibilidade: se chamarem sem "create", trata como create
 program
-  .argument("[projectDir]")
-  .option("--backend-app <name>")
-  .option("--frontend-app <name>")
-  .option("--node <version>", "20.x")
-  .option("--region <region>", "eu");
+  .argument("[projectDir]", "Diretório do projeto (será criado)")
+  .option("--backend-app <name>", "Nome da app Heroku do backend (Strapi)")
+  .option("--frontend-app <name>", "Nome da app Heroku do frontend (Next)")
+  .option("--node <version>", "Versão Node para Heroku (ex: 20.x)", "20.x")
+  .option("--region <region>", "Heroku region (eu | us)", "eu");
 
+// Comando publish
 program
   .command("publish")
-  .argument("[projectDir]")
+  .argument("[projectDir]", "Diretório do projeto (default: .)")
+  .description("Publicar um projeto existente no Heroku")
   .action(async (projectDirArg) => {
     await doPublish(projectDirArg || ".");
   });
 
+// Se executarem sem subcomando, faz create
 program.action(async (projectDirArg, opts) => {
-  if (!projectDirArg) return program.help();
+  if (!projectDirArg) {
+    program.help();
+    return;
+  }
   await doCreate(projectDirArg, opts);
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abw-react-starter",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "CLI para criar projetos Strapi + Next + Heroku",
   "bin": {
     "abw-react-starter": "./bin/create.js"