strapi2front 0.1.6 → 0.2.1

package/dist/bin/strapi2front.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import pc4 from 'picocolors';
-import * as p from '@clack/prompts';
+import * as p3 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) {
-  p.intro(pc4.cyan("strapi2front setup"));
-  p.note(
+  p3.intro(pc4.cyan("strapi2front setup"));
+  p3.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") {
-    p.cancel("Could not detect a supported framework. Currently only Astro is supported.");
+    p3.cancel("Could not detect a supported framework. Currently only Astro is supported.");
     return null;
   }
   if (detection.framework.name !== "astro") {
-    p.cancel(`${detection.framework.name} is not yet supported. Currently only Astro is supported.`);
+    p3.cancel(`${detection.framework.name} is not yet supported. Currently only Astro is supported.`);
     return null;
   }
   const defaultUrl = "http://localhost:1337";
-  const strapiUrlInput = await p.text({
+  const strapiUrlInput = await p3.text({
     message: "What is your Strapi URL?",
     placeholder: `${defaultUrl} (press Enter for default)`,
     validate: (value) => {
@@ -173,24 +173,24 @@ async function runInitPrompts(detection) {
       }
     }
   });
-  if (p.isCancel(strapiUrlInput)) {
-    p.cancel("Setup cancelled");
+  if (p3.isCancel(strapiUrlInput)) {
+    p3.cancel("Setup cancelled");
     return null;
   }
   const strapiUrl = (strapiUrlInput || "").trim() || defaultUrl;
-  const strapiToken = await p.text({
+  const strapiToken = await p3.text({
     message: "What is your Strapi API token?",
     placeholder: "Press Enter to skip (you can add it later in .env)"
   });
-  if (p.isCancel(strapiToken)) {
-    p.cancel("Setup cancelled");
+  if (p3.isCancel(strapiToken)) {
+    p3.cancel("Setup cancelled");
     return null;
   }
   const trimmedToken = (strapiToken || "").trim();
   if (trimmedToken === "") {
-    p.log.info(pc4.dim("Token skipped. Remember to add STRAPI_TOKEN to your .env file later."));
+    p3.log.info(pc4.dim("Token skipped. Remember to add STRAPI_TOKEN to your .env file later."));
   }
-  const strapiVersion = await p.select({
+  const strapiVersion = await p3.select({
     message: "What version of Strapi are you using?",
     options: [
       { value: "v5", label: "Strapi v5", hint: "Recommended - Latest version" },
@@ -198,21 +198,21 @@ async function runInitPrompts(detection) {
     ],
     initialValue: "v5"
   });
-  if (p.isCancel(strapiVersion)) {
-    p.cancel("Setup cancelled");
+  if (p3.isCancel(strapiVersion)) {
+    p3.cancel("Setup cancelled");
     return null;
   }
-  p.log.info(pc4.dim(`Using Strapi ${strapiVersion}. This can be changed later in strapi.config.ts`));
-  const outputDir = await p.text({
+  p3.log.info(pc4.dim(`Using Strapi ${strapiVersion}. This can be changed later in strapi.config.ts`));
+  const outputDir = await p3.text({
     message: "Where should we generate the Strapi files?",
     placeholder: "src/strapi",
     defaultValue: "src/strapi"
   });
-  if (p.isCancel(outputDir)) {
-    p.cancel("Setup cancelled");
+  if (p3.isCancel(outputDir)) {
+    p3.cancel("Setup cancelled");
     return null;
   }
-  const features = await p.multiselect({
+  const features = await p3.multiselect({
     message: "What would you like to generate?",
     options: [
       { value: "types", label: "Types", hint: "TypeScript interfaces for your content types" },
@@ -222,8 +222,8 @@ async function runInitPrompts(detection) {
     initialValues: ["types", "services", "actions"],
     required: true
   });
-  if (p.isCancel(features)) {
-    p.cancel("Setup cancelled");
+  if (p3.isCancel(features)) {
+    p3.cancel("Setup cancelled");
     return null;
   }
   return {
@@ -282,7 +282,7 @@ function execAsync(command, cwd) {
 }
 async function initCommand(_options) {
   const cwd = process.cwd();
-  const s = p.spinner();
+  const s = p3.spinner();
   s.start("Detecting project configuration...");
   const [framework, typescript, packageManager] = await Promise.all([
     detectFramework(cwd),
@@ -317,12 +317,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 p.confirm({
+    const installDeps = await p3.confirm({
       message: "Install required dependencies (strapi2front, strapi-sdk-js)?",
       initialValue: true
     });
-    if (p.isCancel(installDeps)) {
-      p.cancel("Setup cancelled");
+    if (p3.isCancel(installDeps)) {
+      p3.cancel("Setup cancelled");
       process.exit(0);
     }
     if (installDeps) {
@@ -345,11 +345,11 @@ async function initCommand(_options) {
         logger.warn(`Please install manually: ${installSdkCmd}`);
       }
     } else {
-      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.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.note(
+    p3.note(
       [
         `${pc4.green("v")} Created ${pc4.cyan("strapi.config.ts")}`,
         `${pc4.green("v")} Updated ${pc4.cyan(".env")} with Strapi credentials`,
@@ -362,7 +362,7 @@ async function initCommand(_options) {
       ].join("\n"),
       "Setup complete!"
     );
-    p.outro(pc4.green("Happy coding!"));
+    p3.outro(pc4.green("Happy coding!"));
   } catch (error) {
     s.stop("Failed to create configuration files");
     logger.error(error instanceof Error ? error.message : "Unknown error");
@@ -377,6 +377,9 @@ 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",
+
   // Output configuration
   output: {
     path: "${answers.outputDir}",
@@ -513,50 +516,73 @@ function cleanOrphanedFiles(outputPath, orphanedItems) {
 }
 async function syncCommand(options) {
   const cwd = process.cwd();
-  p.intro(pc4.cyan("strapi2front sync"));
-  const s = p.spinner();
+  p3.intro(pc4.cyan("strapi2front sync"));
+  const s = p3.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);
+    const versionResult = await detectStrapiVersion(config.url, config.token, config.apiPrefix);
     s.stop("Version detection complete");
     let effectiveVersion = config.strapiVersion;
     if (versionResult.detected) {
       if (versionResult.detected !== config.strapiVersion) {
         if (versionResult.detected === "v5" && config.strapiVersion === "v4") {
-          p.log.warn(
+          p3.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") {
-          p.log.warn(
+          p3.log.warn(
             pc4.yellow(`Detected Strapi ${pc4.bold("v4")} but config has ${pc4.bold("v5")}. Using v4.`)
           );
           effectiveVersion = "v4";
         }
       } else {
-        p.log.info(`Strapi ${pc4.green(pc4.bold(config.strapiVersion))}`);
+        p3.log.info(`Strapi ${pc4.green(pc4.bold(config.strapiVersion))}`);
       }
     } else {
-      p.log.warn(pc4.yellow(`Could not detect Strapi version. Using ${pc4.bold(config.strapiVersion)}`));
+      p3.log.warn(pc4.yellow(`Could not detect Strapi version. Using ${pc4.bold(config.strapiVersion)}`));
     }
     config = { ...config, strapiVersion: effectiveVersion };
     s.start("Fetching schema from Strapi...");
-    const rawSchema = await fetchSchema(config.url, config.token);
+    const rawSchema = await fetchSchema(config.url, config.token, config.apiPrefix);
     const schema = parseSchema(rawSchema);
     s.stop(`Schema fetched: ${schema.collections.length} collections, ${schema.singles.length} singles, ${schema.components.length} components`);
     let blocksRendererInstalled = isPackageInstalled(BLOCKS_RENDERER_PACKAGE, cwd);
     const { hasBlocks: hasBlocksFields, fieldsFound: blocksFieldsFound } = schemaHasBlocks(schema);
     if (hasBlocksFields && !blocksRendererInstalled) {
-      p.log.info(`Blocks fields detected: ${pc4.cyan(blocksFieldsFound.join(", "))}`);
-      const installBlocks = await p.confirm({
+      p3.log.info(`Blocks fields detected: ${pc4.cyan(blocksFieldsFound.join(", "))}`);
+      const installBlocks = await p3.confirm({
         message: `Install ${pc4.cyan(BLOCKS_RENDERER_PACKAGE)} for proper type support and rendering?`,
         initialValue: true
       });
-      if (p.isCancel(installBlocks)) {
-        p.cancel("Sync cancelled");
+      if (p3.isCancel(installBlocks)) {
+        p3.cancel("Sync cancelled");
         process.exit(0);
       }
       if (installBlocks) {
@@ -570,7 +596,7 @@ async function syncCommand(options) {
           logger.warn("You can install it manually later and re-run sync");
         }
       } else {
-        p.log.info(pc4.dim(`Skipping ${BLOCKS_RENDERER_PACKAGE}. BlocksContent will be typed as unknown[]`));
+        p3.log.info(pc4.dim(`Skipping ${BLOCKS_RENDERER_PACKAGE}. BlocksContent will be typed as unknown[]`));
       }
     }
     const outputPath = path5.join(cwd, config.output.path);
@@ -582,18 +608,18 @@ async function syncCommand(options) {
       const orphanedFolders = getOrphanedFolders(outputPath, currentStructure);
       if (orphanedFolders.length > 0) {
         const otherStructure = isByFeature ? "by-layer" : "by-feature";
-        p.log.warn(
+        p3.log.warn(
           pc4.yellow(`Found files from previous ${pc4.bold(otherStructure)} structure:`)
         );
-        p.log.message(pc4.dim(`  ${orphanedFolders.join(", ")}`));
+        p3.log.message(pc4.dim(`  ${orphanedFolders.join(", ")}`));
         let shouldClean = options.clean;
         if (!shouldClean) {
-          const cleanResponse = await p.confirm({
+          const cleanResponse = await p3.confirm({
             message: `Remove orphaned ${otherStructure} files?`,
             initialValue: true
           });
-          if (p.isCancel(cleanResponse)) {
-            p.cancel("Sync cancelled");
+          if (p3.isCancel(cleanResponse)) {
+            p3.cancel("Sync cancelled");
             process.exit(0);
           }
           shouldClean = cleanResponse;
@@ -603,7 +629,7 @@ async function syncCommand(options) {
           cleanOrphanedFiles(outputPath, orphanedFolders);
           s.stop(`Removed: ${orphanedFolders.join(", ")}`);
         } else {
-          p.log.info(pc4.dim("Keeping orphaned files. You can clean them manually or use --clean flag."));
+          p3.log.info(pc4.dim("Keeping orphaned files. You can clean them manually or use --clean flag."));
         }
       }
     }
@@ -617,7 +643,8 @@ async function syncCommand(options) {
           actions: config.features.actions && (generateAll || Boolean(options.actionsOnly))
         },
         blocksRendererInstalled,
-        strapiVersion: config.strapiVersion
+        strapiVersion: config.strapiVersion,
+        apiPrefix: config.apiPrefix
       });
       generatedFiles.push(...files);
       s.stop(`Generated ${files.length} files`);
@@ -638,7 +665,7 @@ async function syncCommand(options) {
       if (generateAll || options.servicesOnly) {
         if (config.features.services) {
           s.start("Generating client...");
-          const clientFiles = await generateClient({ outputDir: outputPath, strapiVersion: config.strapiVersion });
+          const clientFiles = await generateClient({ outputDir: outputPath, strapiVersion: config.strapiVersion, apiPrefix: config.apiPrefix });
           generatedFiles.push(...clientFiles);
           s.stop("Generated client");
           s.start("Generating locales...");
@@ -681,7 +708,7 @@ async function syncCommand(options) {
         }
       }
     }
-    p.note(
+    p3.note(
       [
         `Generated ${generatedFiles.length} files in ${pc4.cyan(config.output.path)}`,
         "",
@@ -691,7 +718,7 @@ async function syncCommand(options) {
       ].filter(Boolean).join("\n"),
       "Sync complete!"
     );
-    p.outro(pc4.green("Types and services are ready to use!"));
+    p3.outro(pc4.green("Types and services are ready to use!"));
   } catch (error) {
     s.stop("Sync failed");
     if (error instanceof Error) {