strapi2front 0.3.2 → 0.4.1

package/dist/bin/strapi2front.js

@@ -2,10 +2,10 @@
 import { Command } from 'commander';
 import pc4 from 'picocolors';
 import * as p from '@clack/prompts';
-import fs4 from 'fs/promises';
-import path5 from 'path';
+import fs5 from 'fs/promises';
+import path6 from 'path';
 import { spawn, execSync } from 'child_process';
-import fs5 from 'fs';
+import fs6 from 'fs';
 import { loadConfig, detectStrapiVersion, fetchSchema, parseSchema } from '@strapi2front/core';
 import { generateByFeature, generateTypes, generateClient, generateLocales, generateServices, generateActions } from '@strapi2front/generators';
 
@@ -24,17 +24,17 @@ var FRAMEWORK_DETECTORS = {
   }
 };
 async function detectFramework(cwd = process.cwd()) {
-  const pkgPath = path5.join(cwd, "package.json");
+  const pkgPath = path6.join(cwd, "package.json");
   try {
-    const pkgContent = await fs4.readFile(pkgPath, "utf-8");
+    const pkgContent = await fs5.readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
     for (const [pkgName, detector] of Object.entries(FRAMEWORK_DETECTORS)) {
       if (deps[pkgName]) {
         for (const configFile of detector.configFiles) {
-          const configPath = path5.join(cwd, configFile);
+          const configPath = path6.join(cwd, configFile);
           try {
-            await fs4.access(configPath);
+            await fs5.access(configPath);
             return {
               name: detector.name,
               version: deps[pkgName],
@@ -70,12 +70,12 @@ function getFrameworkDisplayName(framework) {
 var TS_CONFIG_FILES = ["tsconfig.json", "tsconfig.app.json"];
 async function detectTypeScript(cwd = process.cwd()) {
   for (const configFile of TS_CONFIG_FILES) {
-    const configPath = path5.join(cwd, configFile);
+    const configPath = path6.join(cwd, configFile);
     try {
-      await fs4.access(configPath);
-      const pkgPath = path5.join(cwd, "package.json");
+      await fs5.access(configPath);
+      const pkgPath = path6.join(cwd, "package.json");
       try {
-        const pkgContent = await fs4.readFile(pkgPath, "utf-8");
+        const pkgContent = await fs5.readFile(pkgPath, "utf-8");
         const pkg = JSON.parse(pkgContent);
         const deps = { ...pkg.dependencies, ...pkg.devDependencies };
         return {
@@ -107,9 +107,9 @@ var LOCK_FILES = {
 };
 async function detectPackageManager(cwd = process.cwd()) {
   for (const [lockFile, pm] of Object.entries(LOCK_FILES)) {
-    const lockPath = path5.join(cwd, lockFile);
+    const lockPath = path6.join(cwd, lockFile);
     try {
-      await fs4.access(lockPath);
+      await fs5.access(lockPath);
       return {
         name: pm,
         lockFile
@@ -140,6 +140,34 @@ function getInstallDevCommand(pm, pkg) {
   };
   return commands2[pm];
 }
+async function detectModuleType(cwd = process.cwd()) {
+  try {
+    const packageJsonPath = path6.join(cwd, "package.json");
+    const content = await fs5.readFile(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(content);
+    if (packageJson.type === "module") {
+      return { type: "esm", reason: 'package.json has "type": "module"' };
+    }
+    if (packageJson.type === "commonjs") {
+      return { type: "commonjs", reason: 'package.json has "type": "commonjs"' };
+    }
+  } catch {
+  }
+  const esmIndicators = [
+    "next.config.mjs",
+    "nuxt.config.mjs",
+    "vite.config.mjs",
+    "astro.config.mjs"
+  ];
+  for (const file of esmIndicators) {
+    try {
+      await fs5.access(path6.join(cwd, file));
+      return { type: "esm", reason: `Found ${file} (ESM config file)` };
+    } catch {
+    }
+  }
+  return { type: "commonjs", reason: "Default (no ESM indicators found)" };
+}
 function getMajorVersion(version) {
   if (!version) return null;
   const match = version.replace(/^[\^~]/, "").match(/^(\d+)/);
@@ -350,6 +378,11 @@ async function initCommand(_options) {
   }
   s.start("Creating configuration files...");
   try {
+    let moduleType = "commonjs";
+    if (answers.outputFormat === "jsdoc") {
+      const detected = await detectModuleType(cwd);
+      moduleType = detected.type;
+    }
     const configExtension = answers.outputFormat === "jsdoc" ? "js" : "ts";
     const configContent = generateConfigFile({
       strapiUrl: answers.strapiUrl,
@@ -358,17 +391,18 @@ async function initCommand(_options) {
       outputFormat: answers.outputFormat,
       outputDir: answers.outputDir,
       generateActions: answers.generateActions,
-      generateServices: answers.generateServices
+      generateServices: answers.generateServices,
+      moduleType
     });
-    const configPath = path5.join(cwd, `strapi.config.${configExtension}`);
-    await fs4.writeFile(configPath, configContent, "utf-8");
-    const envPath = path5.join(cwd, ".env");
+    const configPath = path6.join(cwd, `strapi.config.${configExtension}`);
+    await fs5.writeFile(configPath, configContent, "utf-8");
+    const envPath = path6.join(cwd, ".env");
     await appendToEnvFile(envPath, {
       STRAPI_URL: answers.strapiUrl,
       STRAPI_TOKEN: answers.strapiToken
     });
-    const outputPath = path5.join(cwd, answers.outputDir);
-    await fs4.mkdir(outputPath, { recursive: true });
+    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)?",
@@ -428,6 +462,7 @@ async function initCommand(_options) {
 }
 function generateConfigFile(answers) {
   const isTypeScript = answers.outputFormat === "typescript";
+  const useESM = answers.moduleType === "esm";
   if (isTypeScript) {
     return `import { defineConfig } from "strapi2front";
 
@@ -461,6 +496,44 @@ export default defineConfig({
   // Strapi version
   strapiVersion: "${answers.strapiVersion}",
 });
+`;
+  }
+  if (useESM) {
+    return `// @ts-check
+import { defineConfig } from "strapi2front";
+
+export default defineConfig({
+  // Strapi connection
+  url: process.env.STRAPI_URL || "${answers.strapiUrl}",
+  token: process.env.STRAPI_TOKEN,
+
+  // API prefix (default: "/api")
+  apiPrefix: "${answers.apiPrefix}",
+
+  // Output format: "typescript" (.ts) or "jsdoc" (.js with JSDoc)
+  outputFormat: "jsdoc",
+
+  // Module type: auto-detected as ESM
+  moduleType: "esm",
+
+  // Output configuration
+  output: {
+    path: "${answers.outputDir}",
+    types: "types",
+    services: "services",
+    structure: 'by-feature' // or 'by-layer'
+  },
+
+  // Features to generate
+  features: {
+    types: true,
+    services: ${answers.generateServices},
+    actions: false, // Actions require TypeScript
+  },
+
+  // Strapi version
+  strapiVersion: "${answers.strapiVersion}",
+});
 `;
   }
   return `// @ts-check
@@ -500,7 +573,7 @@ module.exports = defineConfig({
 async function appendToEnvFile(envPath, variables) {
   let content = "";
   try {
-    content = await fs4.readFile(envPath, "utf-8");
+    content = await fs5.readFile(envPath, "utf-8");
   } catch {
   }
   const lines = content.split("\n");
@@ -516,7 +589,7 @@ async function appendToEnvFile(envPath, variables) {
   if (newLines.length > 0) {
     const separator = content.endsWith("\n") || content === "" ? "" : "\n";
     const newContent = content + separator + newLines.join("\n") + "\n";
-    await fs4.writeFile(envPath, newContent, "utf-8");
+    await fs5.writeFile(envPath, newContent, "utf-8");
   }
 }
 var BLOCKS_RENDERER_PACKAGE = "@strapi/blocks-react-renderer";
@@ -542,9 +615,9 @@ function schemaHasBlocks(schema) {
 }
 function isPackageInstalled(packageName, cwd) {
   try {
-    const packageJsonPath = path5.join(cwd, "package.json");
-    if (!fs5.existsSync(packageJsonPath)) return false;
-    const packageJson = JSON.parse(fs5.readFileSync(packageJsonPath, "utf-8"));
+    const packageJsonPath = path6.join(cwd, "package.json");
+    if (!fs6.existsSync(packageJsonPath)) return false;
+    const packageJson = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
     const deps = {
       ...packageJson.dependencies,
       ...packageJson.devDependencies
@@ -555,9 +628,9 @@ function isPackageInstalled(packageName, cwd) {
   }
 }
 function detectPackageManager2(cwd) {
-  if (fs5.existsSync(path5.join(cwd, "bun.lockb"))) return "bun";
-  if (fs5.existsSync(path5.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs5.existsSync(path5.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs6.existsSync(path6.join(cwd, "bun.lockb"))) return "bun";
+  if (fs6.existsSync(path6.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs6.existsSync(path6.join(cwd, "yarn.lock"))) return "yarn";
   return "npm";
 }
 function installPackage(packageName, cwd) {
@@ -575,22 +648,22 @@ function getOrphanedFolders(outputPath, currentStructure) {
   if (currentStructure === "by-feature") {
     const byLayerFolders = ["types", "services", "actions"];
     for (const folder of byLayerFolders) {
-      const folderPath = path5.join(outputPath, folder);
-      if (fs5.existsSync(folderPath)) {
+      const folderPath = path6.join(outputPath, folder);
+      if (fs6.existsSync(folderPath)) {
         orphanedFolders.push(folder);
       }
     }
-    if (fs5.existsSync(path5.join(outputPath, "client.ts"))) {
+    if (fs6.existsSync(path6.join(outputPath, "client.ts"))) {
       orphanedFolders.push("client.ts");
     }
-    if (fs5.existsSync(path5.join(outputPath, "locales.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 = path5.join(outputPath, folder);
-      if (fs5.existsSync(folderPath)) {
+      const folderPath = path6.join(outputPath, folder);
+      if (fs6.existsSync(folderPath)) {
         orphanedFolders.push(folder);
       }
     }
@@ -599,13 +672,13 @@ function getOrphanedFolders(outputPath, currentStructure) {
 }
 function cleanOrphanedFiles(outputPath, orphanedItems) {
   for (const item of orphanedItems) {
-    const itemPath = path5.join(outputPath, item);
-    if (fs5.existsSync(itemPath)) {
-      const stat = fs5.statSync(itemPath);
+    const itemPath = path6.join(outputPath, item);
+    if (fs6.existsSync(itemPath)) {
+      const stat = fs6.statSync(itemPath);
       if (stat.isDirectory()) {
-        fs5.rmSync(itemPath, { recursive: true, force: true });
+        fs6.rmSync(itemPath, { recursive: true, force: true });
       } else {
-        fs5.unlinkSync(itemPath);
+        fs6.unlinkSync(itemPath);
       }
     }
   }
@@ -672,12 +745,12 @@ async function syncCommand(options) {
         p.log.info(pc4.dim(`Skipping ${BLOCKS_RENDERER_PACKAGE}. BlocksContent will be typed as unknown[]`));
       }
     }
-    const outputPath = path5.join(cwd, config.output.path);
+    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 (fs5.existsSync(outputPath)) {
+    if (fs6.existsSync(outputPath)) {
       const orphanedFolders = getOrphanedFolders(outputPath, currentStructure);
       if (orphanedFolders.length > 0) {
         const otherStructure = isByFeature ? "by-layer" : "by-feature";
@@ -707,6 +780,17 @@ async function syncCommand(options) {
       }
     }
     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)`);
+      } 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, {
@@ -719,7 +803,8 @@ async function syncCommand(options) {
         blocksRendererInstalled,
         strapiVersion: config.strapiVersion,
         apiPrefix: config.apiPrefix,
-        outputFormat
+        outputFormat,
+        moduleType
       });
       generatedFiles.push(...files);
       s.stop(`Generated ${files.length} files`);
@@ -727,7 +812,7 @@ async function syncCommand(options) {
       if (generateAll || options.typesOnly) {
         if (config.features.types) {
           s.start(`Generating types (${outputFormat})...`);
-          const typesPath = path5.join(outputPath, config.output.types);
+          const typesPath = path6.join(outputPath, config.output.types);
           const files = await generateTypes(schema, {
             outputDir: typesPath,
             blocksRendererInstalled,
@@ -757,8 +842,8 @@ async function syncCommand(options) {
       if (generateAll || options.servicesOnly) {
         if (config.features.services) {
           s.start(`Generating services (${outputFormat})...`);
-          const servicesPath = path5.join(outputPath, config.output.services);
-          const typesImportPath = path5.relative(servicesPath, path5.join(outputPath, config.output.types)).replace(/\\/g, "/") || ".";
+          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,
@@ -772,9 +857,9 @@ async function syncCommand(options) {
       if ((generateAll || options.actionsOnly) && outputFormat === "typescript") {
         if (config.features.actions) {
           s.start("Generating Astro actions...");
-          const actionsPath = path5.join(outputPath, config.output.actions);
-          const servicesPath = path5.join(outputPath, config.output.services);
-          const servicesImportPath = path5.relative(actionsPath, servicesPath).replace(/\\/g, "/") || ".";
+          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,
@@ -790,7 +875,7 @@ async function syncCommand(options) {
         `Generated ${generatedFiles.length} files in ${pc4.cyan(config.output.path)}`,
         "",
         "Files generated:",
-        ...generatedFiles.slice(0, 10).map((f) => `  ${pc4.dim(path5.relative(cwd, f))}`),
+        ...generatedFiles.slice(0, 10).map((f) => `  ${pc4.dim(path6.relative(cwd, f))}`),
         generatedFiles.length > 10 ? `  ${pc4.dim(`... and ${generatedFiles.length - 10} more`)}` : ""
       ].filter(Boolean).join("\n"),
       "Sync complete!"