strapi2front 0.4.2 → 0.5.0

package/dist/bin/strapi2front.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import pc4 from 'picocolors';
+import pc3 from 'picocolors';
 import * as p from '@clack/prompts';
 import fs5 from 'fs/promises';
 import path6 from 'path';
 import { spawn, execSync } from 'child_process';
 import fs6 from 'fs';
 import { loadConfig, detectStrapiVersion, fetchSchema, parseSchema } from '@strapi2front/core';
-import { generateByFeature, generateTypes, generateClient, generateLocales, generateServices, generateActions } from '@strapi2front/generators';
+import { generateByFeature } from '@strapi2front/generators';
 
 var FRAMEWORK_DETECTORS = {
   astro: {
@@ -174,12 +174,12 @@ function getMajorVersion(version) {
   return match ? parseInt(match[1], 10) : null;
 }
 async function runInitPrompts(detection) {
-  p.intro(pc4.cyan("strapi2front setup"));
+  p.intro(pc3.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")}`,
-      `Package Manager: ${pc4.green(detection.packageManager.name)}`
+      `Framework: ${pc3.green(getFrameworkDisplayName(detection.framework.name))} ${detection.framework.version ? pc3.dim(`v${detection.framework.version}`) : ""}`,
+      `TypeScript: ${detection.typescript.enabled ? pc3.green("enabled") : pc3.yellow("disabled")}`,
+      `Package Manager: ${pc3.green(detection.packageManager.name)}`
     ].join("\n"),
     "Detected Configuration"
   );
@@ -191,13 +191,13 @@ async function runInitPrompts(detection) {
   } else {
     const majorVersion = getMajorVersion(detection.framework.version);
     if (majorVersion !== null && majorVersion < 4) {
-      p.log.warn(pc4.yellow(`Astro v${majorVersion} detected. Upgrade to v4+ to enable Actions.`));
+      p.log.warn(pc3.yellow(`Astro v${majorVersion} detected. Upgrade to v4+ to enable Actions.`));
       canGenerateActions = false;
     }
   }
   let outputFormat = "typescript";
   if (!detection.typescript.enabled) {
-    p.log.info(pc4.dim("TypeScript not detected. Files will be generated as JavaScript with JSDoc annotations."));
+    p.log.info(pc3.dim("TypeScript not detected. Files will be generated as JavaScript with JSDoc annotations."));
     outputFormat = "jsdoc";
   }
   const defaultUrl = "http://localhost:1337";
@@ -221,7 +221,7 @@ async function runInitPrompts(detection) {
   }
   const strapiUrl = (strapiUrlInput || "").trim() || defaultUrl;
   p.log.message(
-    pc4.dim(
+    pc3.dim(
       `
   To generate a token: Strapi Admin > Settings > API Tokens > Create new API Token
   Required permissions:
@@ -234,8 +234,8 @@ async function runInitPrompts(detection) {
     )
   );
   const strapiToken = await p.text({
-    message: "What is your Strapi API token?",
-    placeholder: "Press Enter to skip (you can add it later in .env)"
+    message: "What is your Strapi sync token?",
+    placeholder: "Press Enter to skip (you can add it later in .env as STRAPI_SYNC_TOKEN)"
   });
   if (p.isCancel(strapiToken)) {
     p.cancel("Setup cancelled");
@@ -243,7 +243,7 @@ async function runInitPrompts(detection) {
   }
   const trimmedToken = (strapiToken || "").trim();
   if (trimmedToken === "") {
-    p.log.info(pc4.dim("Token skipped. Remember to add STRAPI_TOKEN to your .env file later."));
+    p.log.info(pc3.dim("Token skipped. Remember to add STRAPI_SYNC_TOKEN to your .env file later."));
   }
   const strapiVersion = await p.select({
     message: "What version of Strapi are you using?",
@@ -257,7 +257,7 @@ async function runInitPrompts(detection) {
     p.cancel("Setup cancelled");
     return null;
   }
-  p.log.info(pc4.dim(`Using Strapi ${strapiVersion}. This can be changed later in strapi.config.ts`));
+  p.log.info(pc3.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?",
@@ -277,7 +277,7 @@ async function runInitPrompts(detection) {
   }
   const apiPrefix = (apiPrefixInput || "").trim() || defaultPrefix;
   if (apiPrefix !== defaultPrefix) {
-    p.log.info(pc4.dim(`Using custom API prefix: ${apiPrefix}`));
+    p.log.info(pc3.dim(`Using custom API prefix: ${apiPrefix}`));
   }
   const outputDir = await p.text({
     message: "Where should we generate the Strapi files?",
@@ -301,10 +301,24 @@ async function runInitPrompts(detection) {
       hint: isTypeScript ? "Typed service functions for data fetching" : "Service functions with JSDoc annotations"
     }
   ];
+  if (isTypeScript) {
+    featureOptions.push({
+      value: "schemas",
+      label: "Schemas",
+      hint: "Zod validation schemas for forms (React Hook Form, TanStack Form, etc.)"
+    });
+  }
+  featureOptions.push({
+    value: "upload",
+    label: "Upload",
+    hint: "File upload helpers (action + public client for browser uploads)"
+  });
   if (canGenerateActions && isTypeScript) {
     featureOptions.push({ value: "actions", label: "Astro Actions", hint: "Type-safe actions for client/server" });
   }
-  const initialFeatures = canGenerateActions && isTypeScript ? ["types", "services", "actions"] : ["types", "services"];
+  const initialFeatures = ["types", "services"];
+  if (isTypeScript) initialFeatures.push("schemas");
+  if (canGenerateActions && isTypeScript) initialFeatures.push("actions");
   const features = await p.multiselect({
     message: "What would you like to generate?",
     options: featureOptions,
@@ -315,6 +329,19 @@ async function runInitPrompts(detection) {
     p.cancel("Setup cancelled");
     return null;
   }
+  const selectedFeatures = new Set(features);
+  if (selectedFeatures.has("services") && !selectedFeatures.has("types")) {
+    selectedFeatures.add("types");
+    p.log.info(pc3.dim("Auto-enabled Types (required by Services)"));
+  }
+  if (selectedFeatures.has("actions") && !selectedFeatures.has("services")) {
+    selectedFeatures.add("services");
+    p.log.info(pc3.dim("Auto-enabled Services (required by Actions)"));
+    if (!selectedFeatures.has("types")) {
+      selectedFeatures.add("types");
+      p.log.info(pc3.dim("Auto-enabled Types (required by Services)"));
+    }
+  }
   return {
     strapiUrl,
     strapiToken: trimmedToken,
@@ -322,28 +349,31 @@ async function runInitPrompts(detection) {
     apiPrefix,
     outputFormat,
     outputDir: (outputDir || "").trim() || "src/strapi",
-    generateActions: canGenerateActions && isTypeScript && features.includes("actions"),
-    generateServices: features.includes("services")
+    generateTypes: selectedFeatures.has("types"),
+    generateServices: selectedFeatures.has("services"),
+    generateActions: canGenerateActions && isTypeScript && selectedFeatures.has("actions"),
+    generateSchemas: selectedFeatures.has("schemas"),
+    generateUpload: selectedFeatures.has("upload")
   };
 }
 var logger = {
   info: (message) => {
-    console.log(pc4.blue("i"), message);
+    console.log(pc3.blue("i"), message);
   },
   success: (message) => {
-    console.log(pc4.green("v"), message);
+    console.log(pc3.green("v"), message);
   },
   warn: (message) => {
-    console.log(pc4.yellow("!"), message);
+    console.log(pc3.yellow("!"), message);
   },
   error: (message) => {
-    console.log(pc4.red("x"), message);
+    console.log(pc3.red("x"), message);
   },
   step: (message) => {
-    console.log(pc4.cyan(">"), message);
+    console.log(pc3.cyan(">"), message);
   },
   dim: (message) => {
-    console.log(pc4.dim(message));
+    console.log(pc3.dim(message));
   },
   newLine: () => {
     console.log("");
@@ -403,22 +433,35 @@ async function initCommand(_options) {
       apiPrefix: answers.apiPrefix,
       outputFormat: answers.outputFormat,
       outputDir: answers.outputDir,
-      generateActions: answers.generateActions,
+      generateTypes: answers.generateTypes,
       generateServices: answers.generateServices,
+      generateActions: answers.generateActions,
+      generateSchemas: answers.generateSchemas,
+      generateUpload: answers.generateUpload,
       moduleType
     });
     const configPath = path6.join(cwd, `strapi.config.${configExtension}`);
     await fs5.writeFile(configPath, configContent, "utf-8");
     const envPath = path6.join(cwd, ".env");
-    await appendToEnvFile(envPath, {
+    const envVars = {
       STRAPI_URL: answers.strapiUrl,
-      STRAPI_TOKEN: answers.strapiToken
-    });
+      STRAPI_SYNC_TOKEN: answers.strapiToken,
+      // Token for syncing schema (dev only)
+      STRAPI_TOKEN: ""
+      // Token for frontend API calls (production)
+    };
+    if (answers.generateUpload) {
+      envVars.PUBLIC_STRAPI_URL = answers.strapiUrl;
+      envVars.PUBLIC_STRAPI_UPLOAD_TOKEN = "";
+    }
+    await appendToEnvFile(envPath, envVars, answers.generateUpload);
+    const envExamplePath = path6.join(cwd, ".env.example");
+    await createEnvExampleFile(envExamplePath, answers.generateUpload);
     const outputPath = path6.join(cwd, answers.outputDir);
     await fs5.mkdir(outputPath, { recursive: true });
     s.stop("Configuration files created");
     const installDeps = await p.confirm({
-      message: "Install required dependencies (strapi2front, strapi-sdk-js)?",
+      message: "Install required dependencies (strapi2front, @strapi/client)?",
       initialValue: true
     });
     if (p.isCancel(installDeps)) {
@@ -427,49 +470,52 @@ async function initCommand(_options) {
     }
     if (installDeps) {
       const installStrapi2frontCmd = getInstallDevCommand(packageManager.name, "strapi2front");
-      s.start(`Installing strapi2front... (${pc4.dim(installStrapi2frontCmd)})`);
+      s.start(`Installing strapi2front... (${pc3.dim(installStrapi2frontCmd)})`);
       try {
         await execAsync(installStrapi2frontCmd, cwd);
-        s.stop(`${pc4.green("\u2713")} strapi2front installed`);
+        s.stop(`${pc3.green("\u2713")} strapi2front installed`);
       } catch {
-        s.stop(`${pc4.red("\u2717")} Failed to install strapi2front`);
+        s.stop(`${pc3.red("\u2717")} Failed to install strapi2front`);
         logger.warn(`Please install manually: ${installStrapi2frontCmd}`);
       }
-      const installSdkCmd = getInstallCommand(packageManager.name, "strapi-sdk-js");
-      s.start(`Installing strapi-sdk-js... (${pc4.dim(installSdkCmd)})`);
+      const installSdkCmd = getInstallCommand(packageManager.name, "@strapi/client");
+      s.start(`Installing @strapi/client... (${pc3.dim(installSdkCmd)})`);
       try {
         await execAsync(installSdkCmd, cwd);
-        s.stop(`${pc4.green("\u2713")} strapi-sdk-js installed`);
+        s.stop(`${pc3.green("\u2713")} @strapi/client installed`);
       } catch {
-        s.stop(`${pc4.red("\u2717")} Failed to install strapi-sdk-js`);
+        s.stop(`${pc3.red("\u2717")} Failed to install @strapi/client`);
         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")}`));
+      p.log.info(pc3.dim("Remember to install dependencies manually:"));
+      p.log.info(pc3.dim(`  ${getInstallDevCommand(packageManager.name, "strapi2front")}`));
+      p.log.info(pc3.dim(`  ${getInstallCommand(packageManager.name, "@strapi/client")}`));
     }
     const configFileName = `strapi.config.${configExtension}`;
     const fileExt = answers.outputFormat === "jsdoc" ? ".js" : ".ts";
     p.note(
       [
-        `${pc4.green("\u2713")} Created ${pc4.cyan(configFileName)}`,
-        `${pc4.green("\u2713")} Updated ${pc4.cyan(".env")} with Strapi credentials`,
-        `${pc4.green("\u2713")} Created output directory ${pc4.cyan(answers.outputDir)}`,
+        `${pc3.green("\u2713")} Created ${pc3.cyan(configFileName)}`,
+        `${pc3.green("\u2713")} Updated ${pc3.cyan(".env")} with Strapi tokens`,
+        `${pc3.green("\u2713")} Created ${pc3.cyan(".env.example")} for reference`,
+        `${pc3.green("\u2713")} Created output directory ${pc3.cyan(answers.outputDir)}`,
         "",
-        `Output format: ${pc4.cyan(answers.outputFormat === "jsdoc" ? "JavaScript (JSDoc)" : "TypeScript")}`,
+        `Output format: ${pc3.cyan(answers.outputFormat === "jsdoc" ? "JavaScript (JSDoc)" : "TypeScript")}`,
         "",
         `Next steps:`,
-        `  1. Run ${pc4.cyan("npx strapi2front sync")} to generate files`,
-        `  2. Import from ${pc4.cyan(answers.outputDir + "/collections/*" + fileExt)}`,
-        `  3. Import services from ${pc4.cyan(answers.outputDir + "/collections/*.service" + fileExt)}`
+        `  1. Run ${pc3.cyan("npx strapi2front sync")} to generate files`,
+        `  2. Import from ${pc3.cyan(answers.outputDir + "/collections/*" + fileExt)}`,
+        "",
+        `Docs: ${pc3.dim("https://strapi2front.dev/docs")}`
       ].join("\n"),
       "Setup complete!"
     );
-    p.outro(pc4.green("Happy coding!"));
+    p.outro(pc3.green("Happy coding!"));
   } catch (error) {
     s.stop("Failed to create configuration files");
     logger.error(error instanceof Error ? error.message : "Unknown error");
+    logger.info(`Docs: ${pc3.dim("https://strapi2front.dev/docs/installation")}`);
     process.exit(1);
   }
 }
@@ -482,7 +528,8 @@ function generateConfigFile(answers) {
 export default defineConfig({
   // Strapi connection
   url: process.env.STRAPI_URL || "${answers.strapiUrl}",
-  token: process.env.STRAPI_TOKEN,
+  // Token for syncing schema (uses STRAPI_SYNC_TOKEN with fallback to STRAPI_TOKEN)
+  token: process.env.STRAPI_SYNC_TOKEN || process.env.STRAPI_TOKEN,
 
   // API prefix (default: "/api")
   apiPrefix: "${answers.apiPrefix}",
@@ -493,17 +540,15 @@ export default defineConfig({
   // Output configuration
   output: {
     path: "${answers.outputDir}",
-    types: "types",
-    services: "services",
-    actions: "actions/strapi",
-    structure: 'by-feature' // or 'by-layer'
   },
 
   // Features to generate
   features: {
-    types: true,
+    types: ${answers.generateTypes},
     services: ${answers.generateServices},
     actions: ${answers.generateActions},
+    schemas: ${answers.generateSchemas}, // Zod schemas for form validation (React Hook Form, TanStack Form, etc.)
+    upload: ${answers.generateUpload}, // File upload helpers (action + public client)
   },
 
   // Strapi version
@@ -518,7 +563,8 @@ import { defineConfig } from "strapi2front";
 export default defineConfig({
   // Strapi connection
   url: process.env.STRAPI_URL || "${answers.strapiUrl}",
-  token: process.env.STRAPI_TOKEN,
+  // Token for syncing schema (uses STRAPI_SYNC_TOKEN with fallback to STRAPI_TOKEN)
+  token: process.env.STRAPI_SYNC_TOKEN || process.env.STRAPI_TOKEN,
 
   // API prefix (default: "/api")
   apiPrefix: "${answers.apiPrefix}",
@@ -532,16 +578,15 @@ export default defineConfig({
   // Output configuration
   output: {
     path: "${answers.outputDir}",
-    types: "types",
-    services: "services",
-    structure: 'by-feature' // or 'by-layer'
   },
 
   // Features to generate
   features: {
-    types: true,
+    types: ${answers.generateTypes},
     services: ${answers.generateServices},
     actions: false, // Actions require TypeScript
+    schemas: ${answers.generateSchemas},
+    upload: ${answers.generateUpload},
   },
 
   // Strapi version
@@ -555,7 +600,8 @@ const { defineConfig } = require("strapi2front");
 module.exports = defineConfig({
   // Strapi connection
   url: process.env.STRAPI_URL || "${answers.strapiUrl}",
-  token: process.env.STRAPI_TOKEN,
+  // Token for syncing schema (uses STRAPI_SYNC_TOKEN with fallback to STRAPI_TOKEN)
+  token: process.env.STRAPI_SYNC_TOKEN || process.env.STRAPI_TOKEN,
 
   // API prefix (default: "/api")
   apiPrefix: "${answers.apiPrefix}",
@@ -566,16 +612,15 @@ module.exports = defineConfig({
   // Output configuration
   output: {
     path: "${answers.outputDir}",
-    types: "types",
-    services: "services",
-    structure: 'by-feature' // or 'by-layer'
   },
 
   // Features to generate
   features: {
-    types: true,
+    types: ${answers.generateTypes},
     services: ${answers.generateServices},
     actions: false, // Actions require TypeScript
+    schemas: ${answers.generateSchemas},
+    upload: ${answers.generateUpload},
   },
 
   // Strapi version
@@ -583,7 +628,7 @@ module.exports = defineConfig({
 });
 `;
 }
-async function appendToEnvFile(envPath, variables) {
+async function appendToEnvFile(envPath, variables, includeUploadComment = false) {
   let content = "";
   try {
     content = await fs5.readFile(envPath, "utf-8");
@@ -596,6 +641,20 @@ async function appendToEnvFile(envPath, variables) {
   const newLines = [];
   for (const [key, value] of Object.entries(variables)) {
     if (!existingKeys.has(key)) {
+      if (key === "STRAPI_SYNC_TOKEN") {
+        newLines.push("");
+        newLines.push("# Sync token: Used by strapi2front to sync schema (development only)");
+        newLines.push("# Permissions: content-type-builder (getContentTypes, getComponents), i18n (listLocales)");
+        newLines.push("# IMPORTANT: Do NOT deploy this token to production");
+      } else if (key === "STRAPI_TOKEN") {
+        newLines.push("");
+        newLines.push("# Frontend token: Used by your app to fetch content (production)");
+        newLines.push("# Configure with only the permissions your app needs");
+      } else if (key === "PUBLIC_STRAPI_UPLOAD_TOKEN" && includeUploadComment) {
+        newLines.push("");
+        newLines.push("# Upload token: Create in Strapi Admin > Settings > API Tokens");
+        newLines.push("# Set permissions: Upload > upload (only, no delete/update)");
+      }
       newLines.push(`${key}=${value}`);
     }
   }
@@ -605,6 +664,33 @@ async function appendToEnvFile(envPath, variables) {
     await fs5.writeFile(envPath, newContent, "utf-8");
   }
 }
+async function createEnvExampleFile(envExamplePath, includeUpload = false) {
+  const lines = [
+    "# Strapi URL",
+    "STRAPI_URL=http://localhost:1337",
+    "",
+    "# Sync token: Used by strapi2front to sync schema (development only)",
+    "# Permissions: content-type-builder (getContentTypes, getComponents), i18n (listLocales)",
+    "# IMPORTANT: Do NOT deploy this token to production",
+    "STRAPI_SYNC_TOKEN=",
+    "",
+    "# Frontend token: Used by your app to fetch content (production)",
+    "# Configure with only the permissions your app needs",
+    "STRAPI_TOKEN="
+  ];
+  if (includeUpload) {
+    lines.push(
+      "",
+      "# Public URL for browser-side uploads",
+      "PUBLIC_STRAPI_URL=http://localhost:1337",
+      "",
+      "# Upload token: Create in Strapi Admin > Settings > API Tokens",
+      "# Set permissions: Upload > upload (only, no delete/update)",
+      "PUBLIC_STRAPI_UPLOAD_TOKEN="
+    );
+  }
+  await fs5.writeFile(envExamplePath, lines.join("\n") + "\n", "utf-8");
+}
 var BLOCKS_RENDERER_PACKAGE = "@strapi/blocks-react-renderer";
 function schemaHasBlocks(schema) {
   const fieldsFound = [];
@@ -656,49 +742,9 @@ function installPackage(packageName, cwd) {
   };
   execSync(commands2[pm], { cwd, stdio: "inherit" });
 }
-function getOrphanedFolders(outputPath, currentStructure) {
-  const orphanedFolders = [];
-  if (currentStructure === "by-feature") {
-    const byLayerFolders = ["types", "services", "actions"];
-    for (const folder of byLayerFolders) {
-      const folderPath = path6.join(outputPath, folder);
-      if (fs6.existsSync(folderPath)) {
-        orphanedFolders.push(folder);
-      }
-    }
-    if (fs6.existsSync(path6.join(outputPath, "client.ts"))) {
-      orphanedFolders.push("client.ts");
-    }
-    if (fs6.existsSync(path6.join(outputPath, "locales.ts"))) {
-      orphanedFolders.push("locales.ts");
-    }
-  } else {
-    const byFeatureFolders = ["collections", "singles", "shared", "components"];
-    for (const folder of byFeatureFolders) {
-      const folderPath = path6.join(outputPath, folder);
-      if (fs6.existsSync(folderPath)) {
-        orphanedFolders.push(folder);
-      }
-    }
-  }
-  return orphanedFolders;
-}
-function cleanOrphanedFiles(outputPath, orphanedItems) {
-  for (const item of orphanedItems) {
-    const itemPath = path6.join(outputPath, item);
-    if (fs6.existsSync(itemPath)) {
-      const stat = fs6.statSync(itemPath);
-      if (stat.isDirectory()) {
-        fs6.rmSync(itemPath, { recursive: true, force: true });
-      } else {
-        fs6.unlinkSync(itemPath);
-      }
-    }
-  }
-}
 async function syncCommand(options) {
   const cwd = process.cwd();
-  p.intro(pc4.cyan("strapi2front sync"));
+  p.intro(pc3.cyan("strapi2front sync"));
   const s = p.spinner();
   try {
     s.start("Loading configuration...");
@@ -712,20 +758,20 @@ async function syncCommand(options) {
       if (versionResult.detected !== config.strapiVersion) {
         if (versionResult.detected === "v5" && config.strapiVersion === "v4") {
           p.log.warn(
-            pc4.yellow(`Detected Strapi ${pc4.bold("v5")} but config has ${pc4.bold("v4")}. Using v5.`)
+            pc3.yellow(`Detected Strapi ${pc3.bold("v5")} but config has ${pc3.bold("v4")}. Using v5.`)
           );
           effectiveVersion = "v5";
         } else if (versionResult.detected === "v4" && config.strapiVersion === "v5") {
           p.log.warn(
-            pc4.yellow(`Detected Strapi ${pc4.bold("v4")} but config has ${pc4.bold("v5")}. Using v4.`)
+            pc3.yellow(`Detected Strapi ${pc3.bold("v4")} but config has ${pc3.bold("v5")}. Using v4.`)
           );
           effectiveVersion = "v4";
         }
       } else {
-        p.log.info(`Strapi ${pc4.green(pc4.bold(config.strapiVersion))}`);
+        p.log.info(`Strapi ${pc3.green(pc3.bold(config.strapiVersion))}`);
       }
     } else {
-      p.log.warn(pc4.yellow(`Could not detect Strapi version. Using ${pc4.bold(config.strapiVersion)}`));
+      p.log.warn(pc3.yellow(`Could not detect Strapi version. Using ${pc3.bold(config.strapiVersion)}`));
     }
     config = { ...config, strapiVersion: effectiveVersion };
     s.start("Fetching schema from Strapi...");
@@ -735,9 +781,9 @@ async function syncCommand(options) {
     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(", "))}`);
+      p.log.info(`Blocks fields detected: ${pc3.cyan(blocksFieldsFound.join(", "))}`);
       const installBlocks = await p.confirm({
-        message: `Install ${pc4.cyan(BLOCKS_RENDERER_PACKAGE)} for proper type support and rendering?`,
+        message: `Install ${pc3.cyan(BLOCKS_RENDERER_PACKAGE)} for proper type support and rendering?`,
         initialValue: true
       });
       if (p.isCancel(installBlocks)) {
@@ -755,145 +801,62 @@ 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[]`));
+        p.log.info(pc3.dim(`Skipping ${BLOCKS_RENDERER_PACKAGE}. BlocksContent will be typed as unknown[]`));
       }
     }
     const outputPath = path6.join(cwd, config.output.path);
     const generatedFiles = [];
-    const generateAll = !options.typesOnly && !options.servicesOnly && !options.actionsOnly;
-    const isByFeature = config.output.structure === "by-feature";
-    const currentStructure = isByFeature ? "by-feature" : "by-layer";
-    if (fs6.existsSync(outputPath)) {
-      const orphanedFolders = getOrphanedFolders(outputPath, currentStructure);
-      if (orphanedFolders.length > 0) {
-        const otherStructure = isByFeature ? "by-layer" : "by-feature";
-        p.log.warn(
-          pc4.yellow(`Found files from previous ${pc4.bold(otherStructure)} structure:`)
-        );
-        p.log.message(pc4.dim(`  ${orphanedFolders.join(", ")}`));
-        let shouldClean = options.clean;
-        if (!shouldClean) {
-          const cleanResponse = await p.confirm({
-            message: `Remove orphaned ${otherStructure} files?`,
-            initialValue: true
-          });
-          if (p.isCancel(cleanResponse)) {
-            p.cancel("Sync cancelled");
-            process.exit(0);
-          }
-          shouldClean = cleanResponse;
-        }
-        if (shouldClean) {
-          s.start("Cleaning orphaned files...");
-          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."));
-        }
-      }
-    }
+    const generateAll = !options.typesOnly && !options.servicesOnly && !options.actionsOnly && !options.schemasOnly && !options.uploadOnly;
     const outputFormat = config.outputFormat || "typescript";
     let moduleType = "commonjs";
     if (outputFormat === "jsdoc") {
       if (config.moduleType) {
         moduleType = config.moduleType;
-        p.log.info(`Module type: ${pc4.cyan(moduleType)} (from config)`);
+        p.log.info(`Module type: ${pc3.cyan(moduleType)} (from config)`);
       } else {
         const detected = await detectModuleType(cwd);
         moduleType = detected.type;
-        p.log.info(`Module type: ${pc4.cyan(moduleType)} (${detected.reason})`);
-      }
-    }
-    if (isByFeature) {
-      s.start(`Generating files (by-feature, ${outputFormat})...`);
-      const files = await generateByFeature(schema, rawSchema.locales, {
-        outputDir: outputPath,
-        features: {
-          types: config.features.types && (generateAll || Boolean(options.typesOnly)),
-          services: config.features.services && (generateAll || Boolean(options.servicesOnly)),
-          actions: config.features.actions && outputFormat === "typescript" && (generateAll || Boolean(options.actionsOnly))
-        },
-        blocksRendererInstalled,
-        strapiVersion: config.strapiVersion,
-        apiPrefix: config.apiPrefix,
-        outputFormat,
-        moduleType
-      });
-      generatedFiles.push(...files);
-      s.stop(`Generated ${files.length} files`);
-    } else {
-      if (generateAll || options.typesOnly) {
-        if (config.features.types) {
-          s.start(`Generating types (${outputFormat})...`);
-          const typesPath = path6.join(outputPath, config.output.types);
-          const files = await generateTypes(schema, {
-            outputDir: typesPath,
-            blocksRendererInstalled,
-            strapiVersion: config.strapiVersion,
-            outputFormat
-          });
-          generatedFiles.push(...files);
-          s.stop(`Generated ${files.length} type files`);
-        }
-      }
-      if (generateAll || options.servicesOnly) {
-        if (config.features.services) {
-          s.start("Generating client...");
-          const clientFiles = await generateClient({ outputDir: outputPath, strapiVersion: config.strapiVersion, apiPrefix: config.apiPrefix });
-          generatedFiles.push(...clientFiles);
-          s.stop("Generated client");
-          s.start("Generating locales...");
-          const localesFiles = await generateLocales(rawSchema.locales, { outputDir: outputPath });
-          generatedFiles.push(...localesFiles);
-          if (rawSchema.locales.length > 0) {
-            s.stop(`Generated locales: ${rawSchema.locales.map((l) => l.code).join(", ")}`);
-          } else {
-            s.stop("Generated locales (i18n not enabled in Strapi)");
-          }
-        }
-      }
-      if (generateAll || options.servicesOnly) {
-        if (config.features.services) {
-          s.start(`Generating services (${outputFormat})...`);
-          const servicesPath = path6.join(outputPath, config.output.services);
-          const typesImportPath = path6.relative(servicesPath, path6.join(outputPath, config.output.types)).replace(/\\/g, "/") || ".";
-          const files = await generateServices(schema, {
-            outputDir: servicesPath,
-            typesImportPath: typesImportPath.startsWith(".") ? typesImportPath : "./" + typesImportPath,
-            strapiVersion: config.strapiVersion,
-            outputFormat
-          });
-          generatedFiles.push(...files);
-          s.stop(`Generated ${files.length} service files`);
-        }
-      }
-      if ((generateAll || options.actionsOnly) && outputFormat === "typescript") {
-        if (config.features.actions) {
-          s.start("Generating Astro actions...");
-          const actionsPath = path6.join(outputPath, config.output.actions);
-          const servicesPath = path6.join(outputPath, config.output.services);
-          const servicesImportPath = path6.relative(actionsPath, servicesPath).replace(/\\/g, "/") || ".";
-          const files = await generateActions(schema, {
-            outputDir: actionsPath,
-            servicesImportPath: servicesImportPath.startsWith(".") ? servicesImportPath : "./" + servicesImportPath,
-            strapiVersion: config.strapiVersion
-          });
-          generatedFiles.push(...files);
-          s.stop(`Generated ${files.length} action files`);
-        }
+        p.log.info(`Module type: ${pc3.cyan(moduleType)} (${detected.reason})`);
       }
     }
+    s.start(`Generating files (${outputFormat})...`);
+    const files = await generateByFeature(schema, rawSchema.locales, {
+      outputDir: outputPath,
+      features: {
+        types: config.features.types && (generateAll || Boolean(options.typesOnly)),
+        services: config.features.services && (generateAll || Boolean(options.servicesOnly)),
+        actions: config.features.actions && outputFormat === "typescript" && (generateAll || Boolean(options.actionsOnly)),
+        schemas: config.features.schemas && (generateAll || Boolean(options.schemasOnly)),
+        upload: config.features.upload && (generateAll || Boolean(options.uploadOnly))
+      },
+      schemaOptions: config.schemaOptions,
+      blocksRendererInstalled,
+      strapiVersion: config.strapiVersion,
+      apiPrefix: config.apiPrefix,
+      outputFormat,
+      moduleType
+    });
+    generatedFiles.push(...files);
+    s.stop(`Generated ${files.length} files`);
     p.note(
       [
-        `Generated ${generatedFiles.length} files in ${pc4.cyan(config.output.path)}`,
+        `Generated ${generatedFiles.length} files in ${pc3.cyan(config.output.path)}`,
         "",
         "Files generated:",
-        ...generatedFiles.slice(0, 10).map((f) => `  ${pc4.dim(path6.relative(cwd, f))}`),
-        generatedFiles.length > 10 ? `  ${pc4.dim(`... and ${generatedFiles.length - 10} more`)}` : ""
+        ...generatedFiles.slice(0, 10).map((f) => `  ${pc3.dim(path6.relative(cwd, f))}`),
+        generatedFiles.length > 10 ? `  ${pc3.dim(`... and ${generatedFiles.length - 10} more`)}` : "",
+        "",
+        `Docs: ${pc3.dim("https://strapi2front.dev/docs")}`
       ].filter(Boolean).join("\n"),
       "Sync complete!"
     );
-    p.outro(pc4.green("Types and services are ready to use!"));
+    const generatedFeatures = [];
+    if (config.features.types) generatedFeatures.push("Types");
+    if (config.features.services) generatedFeatures.push("Services");
+    if (config.features.schemas) generatedFeatures.push("Schemas");
+    if (config.features.actions) generatedFeatures.push("Actions");
+    if (config.features.upload) generatedFeatures.push("Upload");
+    p.outro(pc3.green(`${generatedFeatures.join(", ")} ready to use!`));
   } catch (error) {
     s.stop("Sync failed");
     if (error instanceof Error) {
@@ -904,6 +867,7 @@ async function syncCommand(options) {
     } else {
       logger.error("An unknown error occurred");
     }
+    logger.info(`Docs: ${pc3.dim("https://strapi2front.dev/docs")}`);
     process.exit(1);
   }
 }
@@ -918,14 +882,14 @@ var logo = `
 |___/\\__|_|  \\__,_| .__/|_|(_) |_| |_|  \\___/|_| |_|\\__|
                   |_|
 `;
-program.name("strapi2front").description("Generate TypeScript types, services, and framework actions from your Strapi schema").version("0.1.0").addHelpText("beforeAll", pc4.cyan(logo));
-program.command("init").description("Initialize strapi2front in your project").option("-y, --yes", "Skip prompts and use defaults").option("--url <url>", "Strapi URL").option("--token <token>", "Strapi API token").option("--framework <framework>", "Framework to use (astro)").action(initCommand);
-program.command("sync").description("Sync types, services, and actions from Strapi schema").option("-f, --force", "Force regeneration of all files").option("--types-only", "Only generate types").option("--services-only", "Only generate services").option("--actions-only", "Only generate actions").option("--clean", "Automatically remove orphaned files from previous structure").action(syncCommand);
+program.name("strapi2front").description("Generate TypeScript types, services, and framework actions from your Strapi schema").version("0.1.0").addHelpText("beforeAll", pc3.cyan(logo));
+program.command("init").description("Initialize strapi2front in your project").option("-y, --yes", "Skip prompts and use defaults").option("--url <url>", "Strapi URL").option("--token <token>", "Strapi sync token (STRAPI_SYNC_TOKEN)").option("--framework <framework>", "Framework to use (astro)").action(initCommand);
+program.command("sync").description("Sync types, schemas, services, actions, and upload helpers from Strapi schema").option("-f, --force", "Force regeneration of all files").option("--types-only", "Only generate types").option("--services-only", "Only generate services").option("--actions-only", "Only generate actions").option("--schemas-only", "Only generate Zod validation schemas").option("--upload-only", "Only generate upload helpers").action(syncCommand);
 var args = process.argv.slice(2);
 var commands = ["init", "sync", "help", "--help", "-h", "--version", "-V"];
 var hasCommand = args.some((arg) => commands.includes(arg));
 if (args.length === 0 || !hasCommand) {
-  console.log(pc4.cyan(logo));
+  console.log(pc3.cyan(logo));
   initCommand();
 } else {
   program.parse();