strapi2front 0.2.1 → 0.2.3

package/dist/bin/strapi2front.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import pc4 from 'picocolors';
-import * as p3 from '@clack/prompts';
+import * as p from '@clack/prompts';
 import fs4 from 'fs/promises';
 import path5 from 'path';
 import { spawn, execSync } from 'child_process';
@@ -141,8 +141,8 @@ function getInstallDevCommand(pm, pkg) {
   return commands2[pm];
 }
 async function runInitPrompts(detection) {
-  p3.intro(pc4.cyan("strapi2front setup"));
-  p3.note(
+  p.intro(pc4.cyan("strapi2front setup"));
+  p.note(
     [
       `Framework: ${pc4.green(getFrameworkDisplayName(detection.framework.name))} ${detection.framework.version ? pc4.dim(`v${detection.framework.version}`) : ""}`,
       `TypeScript: ${detection.typescript.enabled ? pc4.green("enabled") : pc4.yellow("disabled")}`,
@@ -151,15 +151,15 @@ async function runInitPrompts(detection) {
     "Detected Configuration"
   );
   if (detection.framework.name === "unknown") {
-    p3.cancel("Could not detect a supported framework. Currently only Astro is supported.");
+    p.cancel("Could not detect a supported framework. Currently only Astro is supported.");
     return null;
   }
   if (detection.framework.name !== "astro") {
-    p3.cancel(`${detection.framework.name} is not yet supported. Currently only Astro is supported.`);
+    p.cancel(`${detection.framework.name} is not yet supported. Currently only Astro is supported.`);
     return null;
   }
   const defaultUrl = "http://localhost:1337";
-  const strapiUrlInput = await p3.text({
+  const strapiUrlInput = await p.text({
     message: "What is your Strapi URL?",
     placeholder: `${defaultUrl} (press Enter for default)`,
     validate: (value) => {
@@ -173,24 +173,24 @@ async function runInitPrompts(detection) {
       }
     }
   });
-  if (p3.isCancel(strapiUrlInput)) {
-    p3.cancel("Setup cancelled");
+  if (p.isCancel(strapiUrlInput)) {
+    p.cancel("Setup cancelled");
     return null;
   }
   const strapiUrl = (strapiUrlInput || "").trim() || defaultUrl;
-  const strapiToken = await p3.text({
+  const strapiToken = await p.text({
     message: "What is your Strapi API token?",
     placeholder: "Press Enter to skip (you can add it later in .env)"
   });
-  if (p3.isCancel(strapiToken)) {
-    p3.cancel("Setup cancelled");
+  if (p.isCancel(strapiToken)) {
+    p.cancel("Setup cancelled");
     return null;
   }
   const trimmedToken = (strapiToken || "").trim();
   if (trimmedToken === "") {
-    p3.log.info(pc4.dim("Token skipped. Remember to add STRAPI_TOKEN to your .env file later."));
+    p.log.info(pc4.dim("Token skipped. Remember to add STRAPI_TOKEN to your .env file later."));
   }
-  const strapiVersion = await p3.select({
+  const strapiVersion = await p.select({
     message: "What version of Strapi are you using?",
     options: [
       { value: "v5", label: "Strapi v5", hint: "Recommended - Latest version" },
@@ -198,21 +198,42 @@ async function runInitPrompts(detection) {
     ],
     initialValue: "v5"
   });
-  if (p3.isCancel(strapiVersion)) {
-    p3.cancel("Setup cancelled");
+  if (p.isCancel(strapiVersion)) {
+    p.cancel("Setup cancelled");
     return null;
   }
-  p3.log.info(pc4.dim(`Using Strapi ${strapiVersion}. This can be changed later in strapi.config.ts`));
-  const outputDir = await p3.text({
+  p.log.info(pc4.dim(`Using Strapi ${strapiVersion}. This can be changed later in strapi.config.ts`));
+  const defaultPrefix = "/api";
+  const apiPrefixInput = await p.text({
+    message: "What is your Strapi API prefix?",
+    placeholder: `${defaultPrefix} (press Enter for default)`,
+    validate: (value) => {
+      const trimmed = (value || "").trim();
+      if (trimmed === "") return void 0;
+      if (!trimmed.startsWith("/")) {
+        return "API prefix must start with /";
+      }
+      return void 0;
+    }
+  });
+  if (p.isCancel(apiPrefixInput)) {
+    p.cancel("Setup cancelled");
+    return null;
+  }
+  const apiPrefix = (apiPrefixInput || "").trim() || defaultPrefix;
+  if (apiPrefix !== defaultPrefix) {
+    p.log.info(pc4.dim(`Using custom API prefix: ${apiPrefix}`));
+  }
+  const outputDir = await p.text({
     message: "Where should we generate the Strapi files?",
     placeholder: "src/strapi",
     defaultValue: "src/strapi"
   });
-  if (p3.isCancel(outputDir)) {
-    p3.cancel("Setup cancelled");
+  if (p.isCancel(outputDir)) {
+    p.cancel("Setup cancelled");
     return null;
   }
-  const features = await p3.multiselect({
+  const features = await p.multiselect({
     message: "What would you like to generate?",
     options: [
       { value: "types", label: "Types", hint: "TypeScript interfaces for your content types" },
@@ -222,14 +243,15 @@ async function runInitPrompts(detection) {
     initialValues: ["types", "services", "actions"],
     required: true
   });
-  if (p3.isCancel(features)) {
-    p3.cancel("Setup cancelled");
+  if (p.isCancel(features)) {
+    p.cancel("Setup cancelled");
     return null;
   }
   return {
     strapiUrl,
     strapiToken: trimmedToken,
     strapiVersion,
+    apiPrefix,
     outputDir: (outputDir || "").trim() || "src/strapi",
     generateActions: features.includes("actions"),
     generateServices: features.includes("services")
@@ -282,7 +304,7 @@ function execAsync(command, cwd) {
 }
 async function initCommand(_options) {
   const cwd = process.cwd();
-  const s = p3.spinner();
+  const s = p.spinner();
   s.start("Detecting project configuration...");
   const [framework, typescript, packageManager] = await Promise.all([
     detectFramework(cwd),
@@ -303,6 +325,7 @@ async function initCommand(_options) {
     const configContent = generateConfigFile({
       strapiUrl: answers.strapiUrl,
       strapiVersion: answers.strapiVersion,
+      apiPrefix: answers.apiPrefix,
       outputDir: answers.outputDir,
       generateActions: answers.generateActions,
       generateServices: answers.generateServices
@@ -317,12 +340,12 @@ async function initCommand(_options) {
     const outputPath = path5.join(cwd, answers.outputDir);
     await fs4.mkdir(outputPath, { recursive: true });
     s.stop("Configuration files created");
-    const installDeps = await p3.confirm({
+    const installDeps = await p.confirm({
       message: "Install required dependencies (strapi2front, strapi-sdk-js)?",
       initialValue: true
     });
-    if (p3.isCancel(installDeps)) {
-      p3.cancel("Setup cancelled");
+    if (p.isCancel(installDeps)) {
+      p.cancel("Setup cancelled");
       process.exit(0);
     }
     if (installDeps) {
@@ -345,11 +368,11 @@ async function initCommand(_options) {
         logger.warn(`Please install manually: ${installSdkCmd}`);
       }
     } else {
-      p3.log.info(pc4.dim("Remember to install dependencies manually:"));
-      p3.log.info(pc4.dim(`  ${getInstallDevCommand(packageManager.name, "strapi2front")}`));
-      p3.log.info(pc4.dim(`  ${getInstallCommand(packageManager.name, "strapi-sdk-js")}`));
+      p.log.info(pc4.dim("Remember to install dependencies manually:"));
+      p.log.info(pc4.dim(`  ${getInstallDevCommand(packageManager.name, "strapi2front")}`));
+      p.log.info(pc4.dim(`  ${getInstallCommand(packageManager.name, "strapi-sdk-js")}`));
     }
-    p3.note(
+    p.note(
       [
         `${pc4.green("v")} Created ${pc4.cyan("strapi.config.ts")}`,
         `${pc4.green("v")} Updated ${pc4.cyan(".env")} with Strapi credentials`,
@@ -362,7 +385,7 @@ async function initCommand(_options) {
       ].join("\n"),
       "Setup complete!"
     );
-    p3.outro(pc4.green("Happy coding!"));
+    p.outro(pc4.green("Happy coding!"));
   } catch (error) {
     s.stop("Failed to create configuration files");
     logger.error(error instanceof Error ? error.message : "Unknown error");
@@ -377,8 +400,8 @@ export default defineConfig({
   url: process.env.STRAPI_URL || "${answers.strapiUrl}",
   token: process.env.STRAPI_TOKEN,
 
-  // API prefix (default: "/api", change if you customized it in Strapi)
-  // apiPrefix: "/api",
+  // API prefix (default: "/api")
+  apiPrefix: "${answers.apiPrefix}",
 
   // Output configuration
   output: {
@@ -516,35 +539,12 @@ function cleanOrphanedFiles(outputPath, orphanedItems) {
 }
 async function syncCommand(options) {
   const cwd = process.cwd();
-  p3.intro(pc4.cyan("strapi2front sync"));
-  const s = p3.spinner();
+  p.intro(pc4.cyan("strapi2front sync"));
+  const s = p.spinner();
   try {
     s.start("Loading configuration...");
     let config = await loadConfig(cwd);
     s.stop("Configuration loaded");
-    const currentPrefix = config.apiPrefix || "/api";
-    const apiPrefixInput = await p3.text({
-      message: "What is your Strapi API prefix?",
-      placeholder: `${currentPrefix} (press Enter to use configured value)`,
-      initialValue: currentPrefix,
-      validate: (value) => {
-        const trimmed = (value || "").trim();
-        if (trimmed === "") return void 0;
-        if (!trimmed.startsWith("/")) {
-          return "API prefix must start with /";
-        }
-        return void 0;
-      }
-    });
-    if (p3.isCancel(apiPrefixInput)) {
-      p3.cancel("Sync cancelled");
-      process.exit(0);
-    }
-    const apiPrefix = (apiPrefixInput || "").trim() || currentPrefix;
-    if (apiPrefix !== currentPrefix) {
-      p3.log.info(pc4.dim(`Using API prefix: ${apiPrefix}`));
-      config = { ...config, apiPrefix };
-    }
     s.start("Detecting Strapi version...");
     const versionResult = await detectStrapiVersion(config.url, config.token, config.apiPrefix);
     s.stop("Version detection complete");
@@ -552,21 +552,21 @@ async function syncCommand(options) {
     if (versionResult.detected) {
       if (versionResult.detected !== config.strapiVersion) {
         if (versionResult.detected === "v5" && config.strapiVersion === "v4") {
-          p3.log.warn(
+          p.log.warn(
             pc4.yellow(`Detected Strapi ${pc4.bold("v5")} but config has ${pc4.bold("v4")}. Using v5.`)
           );
           effectiveVersion = "v5";
         } else if (versionResult.detected === "v4" && config.strapiVersion === "v5") {
-          p3.log.warn(
+          p.log.warn(
             pc4.yellow(`Detected Strapi ${pc4.bold("v4")} but config has ${pc4.bold("v5")}. Using v4.`)
           );
           effectiveVersion = "v4";
         }
       } else {
-        p3.log.info(`Strapi ${pc4.green(pc4.bold(config.strapiVersion))}`);
+        p.log.info(`Strapi ${pc4.green(pc4.bold(config.strapiVersion))}`);
       }
     } else {
-      p3.log.warn(pc4.yellow(`Could not detect Strapi version. Using ${pc4.bold(config.strapiVersion)}`));
+      p.log.warn(pc4.yellow(`Could not detect Strapi version. Using ${pc4.bold(config.strapiVersion)}`));
     }
     config = { ...config, strapiVersion: effectiveVersion };
     s.start("Fetching schema from Strapi...");
@@ -576,13 +576,13 @@ async function syncCommand(options) {
     let blocksRendererInstalled = isPackageInstalled(BLOCKS_RENDERER_PACKAGE, cwd);
     const { hasBlocks: hasBlocksFields, fieldsFound: blocksFieldsFound } = schemaHasBlocks(schema);
     if (hasBlocksFields && !blocksRendererInstalled) {
-      p3.log.info(`Blocks fields detected: ${pc4.cyan(blocksFieldsFound.join(", "))}`);
-      const installBlocks = await p3.confirm({
+      p.log.info(`Blocks fields detected: ${pc4.cyan(blocksFieldsFound.join(", "))}`);
+      const installBlocks = await p.confirm({
         message: `Install ${pc4.cyan(BLOCKS_RENDERER_PACKAGE)} for proper type support and rendering?`,
         initialValue: true
       });
-      if (p3.isCancel(installBlocks)) {
-        p3.cancel("Sync cancelled");
+      if (p.isCancel(installBlocks)) {
+        p.cancel("Sync cancelled");
         process.exit(0);
       }
       if (installBlocks) {
@@ -596,7 +596,7 @@ async function syncCommand(options) {
           logger.warn("You can install it manually later and re-run sync");
         }
       } else {
-        p3.log.info(pc4.dim(`Skipping ${BLOCKS_RENDERER_PACKAGE}. BlocksContent will be typed as unknown[]`));
+        p.log.info(pc4.dim(`Skipping ${BLOCKS_RENDERER_PACKAGE}. BlocksContent will be typed as unknown[]`));
       }
     }
     const outputPath = path5.join(cwd, config.output.path);
@@ -608,18 +608,18 @@ async function syncCommand(options) {
       const orphanedFolders = getOrphanedFolders(outputPath, currentStructure);
       if (orphanedFolders.length > 0) {
         const otherStructure = isByFeature ? "by-layer" : "by-feature";
-        p3.log.warn(
+        p.log.warn(
           pc4.yellow(`Found files from previous ${pc4.bold(otherStructure)} structure:`)
         );
-        p3.log.message(pc4.dim(`  ${orphanedFolders.join(", ")}`));
+        p.log.message(pc4.dim(`  ${orphanedFolders.join(", ")}`));
         let shouldClean = options.clean;
         if (!shouldClean) {
-          const cleanResponse = await p3.confirm({
+          const cleanResponse = await p.confirm({
             message: `Remove orphaned ${otherStructure} files?`,
             initialValue: true
           });
-          if (p3.isCancel(cleanResponse)) {
-            p3.cancel("Sync cancelled");
+          if (p.isCancel(cleanResponse)) {
+            p.cancel("Sync cancelled");
             process.exit(0);
           }
           shouldClean = cleanResponse;
@@ -629,7 +629,7 @@ async function syncCommand(options) {
           cleanOrphanedFiles(outputPath, orphanedFolders);
           s.stop(`Removed: ${orphanedFolders.join(", ")}`);
         } else {
-          p3.log.info(pc4.dim("Keeping orphaned files. You can clean them manually or use --clean flag."));
+          p.log.info(pc4.dim("Keeping orphaned files. You can clean them manually or use --clean flag."));
         }
       }
     }
@@ -708,7 +708,7 @@ async function syncCommand(options) {
         }
       }
     }
-    p3.note(
+    p.note(
       [
         `Generated ${generatedFiles.length} files in ${pc4.cyan(config.output.path)}`,
         "",
@@ -718,7 +718,7 @@ async function syncCommand(options) {
       ].filter(Boolean).join("\n"),
       "Sync complete!"
     );
-    p3.outro(pc4.green("Types and services are ready to use!"));
+    p.outro(pc4.green("Types and services are ready to use!"));
   } catch (error) {
     s.stop("Sync failed");
     if (error instanceof Error) {