@codemoreira/esad 1.4.6 → 2.0.0-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemoreira/esad",
-  "version": "1.4.6",
+  "version": "2.0.0-rc.1",
   "description": "Easy Super App Development - Zero-Config CLI and DevTools for React Native Module Federation",
   "main": "src/plugin/index.js",
   "types": "./src/plugin/index.d.ts",

package/src/cli/commands/build.js

@@ -3,40 +3,41 @@ const path = require('path');
 const fs = require('fs-extra');
 const chalk = require('chalk');
 const { getWorkspaceConfig } = require('../utils/config');
-const { resolveProjectDir, listAvailableModules } = require('../utils/resolution');
+const { resolveProjectDir } = require('../utils/resolution');
+const { clearAllDevMode } = require('../utils/transformer');
 
 module.exports = async (options) => {
-  let cwd = process.cwd();
-  
-  // Enforce Workspace Root
   const configObj = getWorkspaceConfig();
   if (!configObj) {
-    console.error(chalk.red(`❌ Error: Call this command from the project root (esad.config.json not found).`));
+    console.error(chalk.red(`❌ Error: esad.config.js not found.`));
     process.exit(1);
   }
 
-  const { projectName } = configObj.data;
+  const config = await configObj.load();
+  const workspaceRoot = configObj.root;
+  const projectName = config.default?.projectName || config.projectName;
+  
+  let cwd = process.cwd();
   
   if (options.id) {
     const targetDir = resolveProjectDir(options.id, configObj);
     if (!targetDir) {
-      console.error(chalk.red(`\n❌ Error: Module not found: ${options.id}`));
-      listAvailableModules(configObj);
+      console.error(chalk.red(`❌ Error: Module not found: ${options.id}`));
       process.exit(1);
     }
     cwd = targetDir;
-  } else {
-    // Build host by default if in root
-    const hostDir = path.join(path.dirname(configObj.path), `${projectName}-host`);
-    if (fs.existsSync(hostDir)) cwd = hostDir;
   }
 
   const platform = options.platform || 'android';
   
-  console.log(`\n🏗️  Building production bundle for ${path.basename(cwd)} (${platform})...\n`);
+  console.log(`\n🏗️  Building production bundle for ${chalk.cyan(path.basename(cwd))} (${platform})...\n`);
   
+  // 1. CLEANUP CONFIG (Avoid shipping local dev URLs)
+  console.log(chalk.gray(`🧹 Cleaning up devMode mappings in esad.config.js...`));
+  clearAllDevMode(configObj.path);
+
   try {
-    const bundleOutput = path.join(cwd, 'build', platform, 'index.bundle');
+    const bundleOutput = path.join(cwd, 'build', 'index.bundle'); // Simplified path as per V2
     fs.ensureDirSync(path.dirname(bundleOutput));
 
     // Run Re.Pack production build
@@ -47,12 +48,13 @@ module.exports = async (options) => {
       '--dev', 'false',
       '--bundle-output', bundleOutput,
       '--assets-dest', path.dirname(bundleOutput)
-    ], cwd);
+    ], { cwd });
     
     console.log(chalk.green(`\n✅ Build complete! Assets generated in build/ directory.`));
-    console.log(`👉 You can now run: esad deploy ${options.id ? `--id ${options.id}` : ''}\n`);
+    console.log(`👉 Next step: 'esad deploy ${options.id || ''}'\n`);
   } catch (err) {
     console.error(chalk.red(`\n❌ Build failed: ${err.message}`));
     process.exit(1);
   }
 };
+

package/src/cli/commands/createModule.js

@@ -8,12 +8,15 @@ const templatesConfig = require('../templates/templates.json');
 module.exports = async (moduleName) => {
   const configObj = getWorkspaceConfig();
   if (!configObj) {
-    console.error(`❌ Error: Call this command from inside an ESAD workspace (esad.config.json not found).`);
+    console.error(`❌ Error: Call this command from inside an ESAD workspace (esad.config.js not found).`);
     return;
   }
 
-  const { projectName } = configObj.data;
+  const config = await configObj.load();
+  const projectName = config.default?.projectName || config.projectName;
+
   const isPrefixed = moduleName.startsWith(`${projectName}-`);
+
   const finalModuleName = isPrefixed ? moduleName : `${projectName}-${moduleName}`;
 
   const workspaceDir = path.dirname(configObj.path);

package/src/cli/commands/deploy.js

@@ -3,110 +3,78 @@ const path = require('path');
 const AdmZip = require('adm-zip');
 const chalk = require('chalk');
 const { getWorkspaceConfig } = require('../utils/config');
-const { resolveModuleMetadata, listAvailableModules } = require('../utils/resolution');
+const { resolveModuleMetadata } = require('../utils/resolution');
 
 module.exports = async (options) => {
-  let cwd = process.cwd();
-  let pkgPath = path.join(cwd, 'package.json');
-  
-  // Enforce Workspace Root
   const configObj = getWorkspaceConfig();
   if (!configObj) {
-    console.error(chalk.red(`❌ Error: Call this command from the project root (esad.config.json not found).`));
+    console.error(chalk.red(`❌ Error: esad.config.js not found in this or parent directories.`));
     process.exit(1);
   }
 
-  const workspaceRoot = path.dirname(configObj.path);
-  const { projectName } = configObj.data;
+  const config = await configObj.load();
+  const workspaceRoot = configObj.root;
+  const projectName = config.default?.projectName || config.projectName;
   
   let moduleId = options.id;
-  
+  let cwd = process.cwd();
+
+  // Resolve Context
   if (moduleId) {
     const meta = resolveModuleMetadata(moduleId, configObj);
     if (!meta) {
-      console.error(chalk.red(`\n❌ Error: Module not found: ${moduleId}`));
-      listAvailableModules(configObj);
+      console.error(chalk.red(`❌ Error: Module not found: ${moduleId}`));
       process.exit(1);
     }
     cwd = meta.path;
-    moduleId = meta.id; // Correct fully qualified ID
-    pkgPath = path.join(cwd, 'package.json');
-    console.log(`📂 Module detected for Deploy: ${path.basename(cwd)}`);
-  } else {
-    // Target host by default if in root
-    const hostDir = path.join(workspaceRoot, `${projectName}-host`);
-    if (fs.existsSync(hostDir)) {
-      cwd = hostDir;
-      pkgPath = path.join(cwd, 'package.json');
-      console.log(chalk.green(`📂 Host detected for Deploy: ${path.basename(cwd)}`));
-    }
   }
 
+  const pkgPath = path.join(cwd, 'package.json');
   if (!fs.existsSync(pkgPath)) {
     console.error(chalk.red(`❌ Error: package.json not found in ${cwd}.`));
     process.exit(1);
   }
 
   const pkg = fs.readJsonSync(pkgPath);
-  moduleId = moduleId || pkg.name;
+  const resolvedModuleId = moduleId || pkg.name;
   const version = options.version || pkg.version;
-  const entry = options.entry || 'index.bundle';
 
-  console.log(`\n☁️  Starting ESAD Deploy for ${moduleId} (v${version})\n`);
-  
-  const config = configObj ? configObj.data : null;
-  if (!config?.deployEndpoint) {
-    console.error(`❌ Error: 'deployEndpoint' not configured in esad.config.json.`);
-    process.exit(1);
-  }
-  
-  const deployUrl = config.deployEndpoint.replace('{{moduleId}}', moduleId);
-  console.log(`📡 Deployment Endpoint Resolved: ${deployUrl}`);
-  
+  console.log(`\n🚀 Starting ESAD Deploy for ${chalk.cyan(resolvedModuleId)} (v${version})\n`);
+
   const distPath = path.join(cwd, 'build');
   if (!fs.existsSync(distPath)) {
-    console.error(`❌ Error: build/ directory not found in ${cwd}. Did you run the build command?`);
+    console.error(chalk.red(`❌ Error: build/ directory not found. Please run 'esad build' first.`));
     process.exit(1);
   }
 
+  // ZIP BUNDLE
   const zip = new AdmZip();
   zip.addLocalFolder(distPath);
+  const buffer = zip.toBuffer();
   
-  const zipPath = path.join(cwd, `bundle-${moduleId}-${version}.zip`);
-  zip.writeZip(zipPath);
-  console.log(`🗜️  Zipped output to ${zipPath}`);
+  console.log(`🗜️  Generated bundle zip (${(buffer.length / 1024).toFixed(2)} KB)`);
 
-  console.log(`🚀 Uploading to CDN via multipart POST...`);
+  // RUN DEPLOY HOOK
+  const deployHook = config.default?.deploy || config.deploy;
   
-  try {
-    const FormData = require('form-data'); // Standard in Node versions, or use native if available
-    const form = new FormData();
-    form.append('version', version);
-    form.append('bundle', fs.createReadStream(zipPath));
-
-    const fetch = (...args) => import('node-fetch').then(({default: fetch}) => fetch(...args));
-    
-    // Simple CDN expects POST /api/admin/assets/:id/versions
-    const uploadUrl = deployUrl.includes('/versions') ? deployUrl : `${deployUrl}/versions`;
+  if (typeof deployHook !== 'function') {
+    console.error(chalk.red(`❌ Error: 'deploy' function not found in esad.config.js.`));
+    process.exit(1);
+  }
 
-    const response = await fetch(uploadUrl, {
-      method: 'POST',
-      body: form,
-      headers: form.getHeaders(),
+  try {
+    console.log(`📡 Invoking custom 'deploy' hook...`);
+    const result = await deployHook(buffer, { 
+      version, 
+      moduleId: resolvedModuleId, 
+      options 
     });
-
-    if (response.ok) {
-      const result = await response.json();
-      console.log(chalk.green(`✅ Successfully uploaded ${moduleId} v${version} to CDN!`));
-      console.log(`📄 Active Version is now: ${result.active_version}`);
-    } else {
-      const errorText = await response.text();
-      console.error(chalk.red(`❌ Failed to upload: ${response.status} ${response.statusText}`));
-      console.error(errorText);
-    }
+    
+    console.log(chalk.green(`\n✅ Deployment successful!`));
+    if (result) console.log(JSON.stringify(result, null, 2));
   } catch (err) {
-    console.error(chalk.red(`❌ Error during upload: ${err.message}`));
-  } finally {
-    fs.unlinkSync(zipPath);
+    console.error(chalk.red(`\n❌ Deployment failed: ${err.message}`));
+    process.exit(1);
   }
 };
+

package/src/cli/commands/dev.js

@@ -1,89 +1,70 @@
-const { spawn } = require('cross-spawn');
+const { runProcess } = require('../utils/process');
 const { getWorkspaceConfig } = require('../utils/config');
 const fs = require('fs-extra');
 const path = require('path');
 const chalk = require('chalk');
 const { prepareNative } = require('../utils/scaffold');
-const { resolveProjectDir, listAvailableModules } = require('../utils/resolution');
+const { resolveProjectDir } = require('../utils/resolution');
 
 module.exports = async (options) => {
-  let cwd = process.cwd();
-  let pkgPath = path.join(cwd, 'package.json');
-  
-  // Enforce Workspace Root
   const configObj = getWorkspaceConfig();
   if (!configObj) {
-    console.error(chalk.red(`❌ Error: Call this command from the project root (esad.config.json not found).`));
+    console.error(chalk.red(`❌ Error: esad.config.js not found. Run this from your project root.`));
     process.exit(1);
   }
 
-  const workspaceRoot = path.dirname(configObj.path);
-  const { projectName } = configObj.data;
+  const config = await configObj.load();
+  const workspaceRoot = configObj.root;
+  const projectName = config.default?.projectName || config.projectName;
   
-  if (options.id) {
-    const targetDir = resolveProjectDir(options.id, configObj);
+  let cwd = process.cwd();
+  let selectedModuleId = options.id;
+
+  if (selectedModuleId) {
+    const targetDir = resolveProjectDir(selectedModuleId, configObj);
     if (!targetDir) {
-      console.error(chalk.red(`\n❌ Error: Module not found: ${options.id}`));
-      listAvailableModules(configObj);
+      console.error(chalk.red(`❌ Error: Module not found: ${selectedModuleId}`));
       process.exit(1);
     }
     cwd = targetDir;
-    pkgPath = path.join(cwd, 'package.json');
-    console.log(chalk.green(`📂 Module detected: ${path.relative(workspaceRoot, cwd)}`));
-  } else {
-    // Target host by default if in root
-    const hostDir = path.join(workspaceRoot, `${projectName}-host`);
-    if (fs.existsSync(hostDir)) {
-      cwd = hostDir;
-      pkgPath = path.join(cwd, 'package.json');
-      console.log(chalk.green(`📂 Host detected: ${path.relative(workspaceRoot, cwd)}`));
-    }
   }
 
+  const pkgPath = path.join(cwd, 'package.json');
   const pkg = fs.readJsonSync(pkgPath);
-  const moduleId = options.id || pkg.name;
+  const moduleId = selectedModuleId || pkg.name;
   const port = options.port || '8081';
 
   // Determine if it's a Host or Module
   const isHost = pkg.name.endsWith('-host') || pkg.dependencies?.['@callstack/repack'];
   
-  // 1. Initial Checks & Automated Native Preparation
   await prepareNative(cwd, 'all');
 
-  if (isHost && !options.id) {
-     console.log(`\n🚀 Starting Host App Dev Server (Re.Pack/Rspack)...\n`);
-     await spawn('npx', ['react-native', 'webpack-start'], { cwd, stdio: 'inherit', shell: true });
+  if (isHost && !selectedModuleId) {
+     console.log(`\n🚀 Starting ${chalk.green('Host App')} Dev Server (Re.Pack/Rspack)...\n`);
+     await runProcess('npx', ['react-native', 'webpack-start'], { cwd });
      return;
   }
 
-  console.log(`\n⚡ Starting ESAD Dev Server for ${moduleId} on port ${port}...\n`);
+  const { updateDevMode, removeDevMode } = require('../utils/transformer');
   
-  const config = configObj ? configObj.data : null;
-  let devApiUrl = config?.devModeEndpoint ? config.devModeEndpoint.replace('{{moduleId}}', moduleId) : null;
-
-  const setDevMode = async (isActive) => {
-    if (!devApiUrl) return;
-    try {
-      const body = { 
-        is_dev_mode: isActive, 
-        ...(isActive && { dev_url: `http://localhost:${port}/index.bundle` }) 
-      };
-      const res = await fetch(devApiUrl, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
-      if (res.ok) console.log(`📡 Registry Sync: Dev Override is ${isActive ? 'ON' : 'OFF'} for module ${moduleId}`);
-    } catch(e) { /* ignore */ }
-  };
-
-  await setDevMode(true);
+  console.log(`\n⚡ Starting ESAD Dev Server for ${chalk.cyan(moduleId)} on port ${port}...\n`);
+  
+  // Automate devMode update in esad.config.js
+  const localBundleUrl = `http://localhost:${port}/index.bundle`;
+  updateDevMode(configObj.path, moduleId, localBundleUrl);
+  console.log(chalk.gray(`📡 Mode: Module Dev. Host configured to load ${moduleId} from ${localBundleUrl}`));
 
-  const proc = spawn('npx', ['react-native', 'webpack-start', '--port', port], { cwd, stdio: 'inherit', shell: true });
+  const proc = runProcess('npx', ['react-native', 'webpack-start', '--port', port], { cwd });
 
   const shutdown = async () => {
-    console.log(`\n🛑 Stopping ESAD Dev Server and reverting registry status...`);
-    await setDevMode(false);
-    proc.kill();
+    console.log(`\n🛑 Stopping ESAD Dev Server and reverting config...`);
+    removeDevMode(configObj.path, moduleId);
+    if (proc.kill) proc.kill();
     process.exit(0);
   };
 
+
   process.on('SIGINT', shutdown);
   process.on('SIGTERM', shutdown);
 };
+

package/src/cli/commands/init.js

@@ -10,34 +10,53 @@ module.exports = async (projectName) => {
   
   fs.ensureDirSync(workspaceDir);
 
-  const configPath = path.join(workspaceDir, 'esad.config.json');
+  const configPath = path.join(workspaceDir, 'esad.config.js');
   if (!fs.existsSync(configPath)) {
-    const configTemplate = {
-      projectName: projectName,
-      registryUrl: "http://localhost:3000/modules",
-      deployEndpoint: "http://localhost:3000/api/admin/modules/{{moduleId}}/versions",
-      devModeEndpoint: "http://localhost:3000/api/admin/modules/{{moduleId}}"
-    };
-    fs.writeJsonSync(configPath, configTemplate, { spaces: 2 });
-    console.log(`✅ Generated dynamic configuration file: esad.config.json`);
+    const configTemplate = `/**
+ * ESAD: Super App Configuration
+ */
+export default {
+  projectName: '${projectName}',
+  
+  // 1. Development Overrides
+  // Managed automatically by 'esad dev'
+  devMode: {},
+
+  // 2. Programmable Deployment
+  // Receives the compiled bundle.
+  async deploy(bundle, { version, moduleId, options }) {
+    console.log('🚀 Starting custom upload for ' + moduleId + '...');
+    
+    // Example: Simple CDN V2 upload
+    // const response = await fetch('http://localhost:3000/api/admin/modules/' + moduleId + '/versions', {
+    //   method: 'POST',
+    //   body: bundle,
+    //   headers: { 'Authorization': 'Bearer YOUR_TOKEN' }
+    // });
+    // return await response.json();
+
+    return { status: 'mock_success', moduleId, version };
+  }
+};
+`;
+    fs.writeFileSync(configPath, configTemplate);
+    console.log(`✅ Generated programmable configuration: esad.config.js`);
   }
 
   const gitignorePath = path.join(workspaceDir, '.gitignore');
   if (!fs.existsSync(gitignorePath)) {
     const hostName = `${projectName}-host`;
     const gitignoreContent = `# ESAD Workspace Git Configuration\n` +
-      `# Ignore everything by default\n` +
       `/*\n\n` +
-      `# Exceptions: Track only the Host and Configs\n` +
       `!/${hostName}/\n` +
-      `!/esad.config.json\n` +
+      `!/esad.config.js\n` +
       `!/.gitignore\n` +
-      `\n# Ignore node_modules\n` +
-      `node_modules/\n`;
+      `\nnode_modules/\n`;
     fs.writeFileSync(gitignorePath, gitignoreContent);
     console.log(`✅ Generated .gitignore`);
   }
 
+
   const hostName = `${projectName}-host`;
   const hostDir = path.join(workspaceDir, hostName);
   

package/src/cli/utils/config.js

@@ -1,11 +1,40 @@
 const fs = require('fs-extra');
 const path = require('path');
+const { createJiti } = require('jiti');
 
 const getWorkspaceConfig = () => {
-  let configPath = path.join(process.cwd(), 'esad.config.json');
-  if (!fs.existsSync(configPath)) configPath = path.join(process.cwd(), '../esad.config.json');
-  if (!fs.existsSync(configPath)) return null;
-  return { path: configPath, data: fs.readJsonSync(configPath) };
+  let current = process.cwd();
+  let configPath = null;
+
+  // Search upwards for esad.config.js
+  while (current !== path.parse(current).root) {
+    const check = path.join(current, 'esad.config.js');
+    if (fs.existsSync(check)) {
+      configPath = check;
+      break;
+    }
+    current = path.dirname(current);
+  }
+
+  if (!configPath) return null;
+
+  try {
+    const jiti = createJiti(__filename);
+    const configModule = jiti.import(configPath);
+    // jiti.import returns a promise for async imports if needed, but for esad.config.js 
+    // we expect a sync structure or we resolve it.
+    // However, jiti v2 import is async.
+    
+    return { 
+      path: configPath, 
+      root: path.dirname(configPath),
+      load: () => configModule 
+    };
+  } catch (err) {
+    console.error(`❌ Failed to load esad.config.js: ${err.message}`);
+    return null;
+  }
 };
 
 module.exports = { getWorkspaceConfig };
+

package/src/cli/utils/transformer.js

@@ -0,0 +1,44 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Safely updates the devMode object in esad.config.js
+ * This uses a simple yet robust regex approach to preserve comments/formatting.
+ */
+const updateDevMode = (configPath, moduleId, url) => {
+  let content = fs.readFileSync(configPath, 'utf8');
+
+  // 1. Ensure devMode object exists
+  if (!content.includes('devMode:')) {
+    // Inject devMode before the last closing brace (naive but effective for clean configs)
+    content = content.replace(/}([^}]*)$/, `  devMode: {},\n}$1`);
+  }
+
+  // 2. Add or update the module entry
+  const entryRegex = new RegExp(`(['"]${moduleId}['"]|${moduleId}):\\s*['"]([^'"]*)['"]`, 'g');
+  
+  if (entryRegex.test(content)) {
+    // Update existing
+    content = content.replace(entryRegex, `$1: '${url}'`);
+  } else {
+    // Insert new entry into devMode object
+    const devModeRegex = /(devMode:\s*{)/;
+    content = content.replace(devModeRegex, `$1\n    '${moduleId}': '${url}',`);
+  }
+
+  fs.writeFileSync(configPath, content);
+};
+
+const clearAllDevMode = (configPath) => {
+  if (!fs.existsSync(configPath)) return;
+  let content = fs.readFileSync(configPath, 'utf8');
+
+  // Remove the entire devMode block
+  const devModeBlockRegex = /\s*devMode:\s*{[\s\S]*?},?/g;
+  content = content.replace(devModeBlockRegex, '');
+
+  fs.writeFileSync(configPath, content);
+};
+
+module.exports = { updateDevMode, removeDevMode, clearAllDevMode };
+